41 files changed, 29781 insertions, 0 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/Caps/AgentPreferencesModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/AgentPreferencesModule.cs
new file mode 100644
index 0000000..8f65a69
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/AgentPreferencesModule.cs
@@ -0,0 +1,182 @@
+/*
+ * 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.IO;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+
+namespace OpenSim.Region.ClientStack.LindenCaps
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "AgentPreferencesModule")]
+    public class AgentPreferencesModule : ISharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private List<Scene> m_scenes = new List<Scene>();
+
+        public void Initialise(IConfigSource source)
+        {
+
+        }
+
+        #region Region module
+
+        public void AddRegion(Scene scene)
+        {
+            lock (m_scenes) m_scenes.Add(scene);
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            lock (m_scenes) m_scenes.Remove(scene);
+            scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            scene = null;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            scene.EventManager.OnRegisterCaps += delegate(UUID agentID, OpenSim.Framework.Capabilities.Caps caps)
+            {
+                RegisterCaps(agentID, caps);
+            };
+        }
+
+        public void PostInitialise() {}
+
+        public void Close() {}
+
+        public string Name { get { return "AgentPreferencesModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void RegisterCaps(UUID agent, Caps caps)
+        {
+            UUID capId = UUID.Random();
+            caps.RegisterHandler("AgentPreferences",
+                new RestStreamHandler("POST", "/CAPS/" + capId,
+                    delegate(string request, string path, string param,
+                        IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+                    {
+                        return UpdateAgentPreferences(request, path, param, agent);
+                    }));
+            caps.RegisterHandler("UpdateAgentLanguage",
+                new RestStreamHandler("POST", "/CAPS/" + capId,
+                    delegate(string request, string path, string param,
+                        IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+                    {
+                        return UpdateAgentPreferences(request, path, param, agent);
+                    }));
+            caps.RegisterHandler("UpdateAgentInformation",
+                new RestStreamHandler("POST", "/CAPS/" + capId,
+                    delegate(string request, string path, string param,
+                        IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+                    {
+                        return UpdateAgentPreferences(request, path, param, agent);
+                    }));
+        }
+
+        public string UpdateAgentPreferences(string request, string path, string param, UUID agent)
+        {
+            OSDMap resp = new OSDMap();
+            // The viewer doesn't do much with the return value, so for now, if there is no preference service,
+            // we'll return a null llsd block for debugging purposes. This may change if someone knows what the
+            // correct server response would be here.
+            if (m_scenes[0].AgentPreferencesService == null)
+            {
+                return OSDParser.SerializeLLSDXmlString(resp);
+            }
+            m_log.DebugFormat("[AgentPrefs]: UpdateAgentPreferences for {0}", agent.ToString());
+            OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            AgentPrefs data = m_scenes[0].AgentPreferencesService.GetAgentPreferences(agent);
+            if (data == null)
+            {
+                data = new AgentPrefs(agent);
+            }
+
+            if (req.ContainsKey("access_prefs"))
+            {
+                OSDMap accessPrefs = (OSDMap)req["access_prefs"];  // We could check with ContainsKey...
+                data.AccessPrefs = accessPrefs["max"].AsString();
+            }
+            if (req.ContainsKey("default_object_perm_masks"))
+            {
+                OSDMap permsMap = (OSDMap)req["default_object_perm_masks"];
+                data.PermEveryone = permsMap["Everyone"].AsInteger();
+                data.PermGroup = permsMap["Group"].AsInteger();
+                data.PermNextOwner = permsMap["NextOwner"].AsInteger();
+            }
+            if (req.ContainsKey("hover_height"))
+            {
+                data.HoverHeight = req["hover_height"].AsReal();
+            }
+            if (req.ContainsKey("language"))
+            {
+                data.Language = req["language"].AsString();
+            }
+            if (req.ContainsKey("language_is_public"))
+            {
+                data.LanguageIsPublic = req["language_is_public"].AsBoolean();
+            }
+            m_scenes[0].AgentPreferencesService.StoreAgentPreferences(data);
+            OSDMap respAccessPrefs = new OSDMap();
+            respAccessPrefs["max"] = data.AccessPrefs;
+            resp["access_prefs"] = respAccessPrefs;
+            OSDMap respDefaultPerms = new OSDMap();
+            respDefaultPerms["Everyone"] = data.PermEveryone;
+            respDefaultPerms["Group"] = data.PermGroup;
+            respDefaultPerms["NextOwner"] = data.PermNextOwner;
+            resp["default_object_perm_masks"] = respDefaultPerms;
+            resp["god_level"] = 0; // *TODO: Add this
+            resp["hover_height"] = data.HoverHeight;
+            resp["language"] = data.Language;
+            resp["language_is_public"] = data.LanguageIsPublic;
+
+            string response = OSDParser.SerializeLLSDXmlString(resp);
+            return response;
+        }
+
+        #endregion Region module
+    }
+}
+
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/AvatarPickerSearchModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/AvatarPickerSearchModule.cs
new file mode 100644
index 0000000..e3c430c
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/AvatarPickerSearchModule.cs
@@ -0,0 +1,136 @@
+/*
+ * 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.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+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 OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "AvatarPickerSearchModule")]
+    public class AvatarPickerSearchModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_scene;
+        private IPeople m_People;
+        private bool m_Enabled = false;
+
+        private string m_URL;
+
+        #region ISharedRegionModule Members
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_URL = config.GetString("Cap_AvatarPickerSearch", string.Empty);
+            // Cap doesn't exist
+            if (m_URL != string.Empty)
+                m_Enabled = true;
+        }
+
+        public void AddRegion(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene = s;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_People = m_scene.RequestModuleInterface<IPeople>();
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "AvatarPickerSearchModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capID = UUID.Random();
+
+            if (m_URL == "localhost")
+            {
+//                m_log.DebugFormat("[AVATAR PICKER SEARCH]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
+                caps.RegisterHandler(
+                    "AvatarPickerSearch",
+                    new AvatarPickerSearchHandler("/CAPS/" + capID + "/", m_People, "AvatarPickerSearch", "Search for avatars by name"));
+            }
+            else
+            {
+                //                m_log.DebugFormat("[AVATAR PICKER SEARCH]: {0} in region {1}", m_URL, m_scene.RegionInfo.RegionName);
+                caps.RegisterHandler("AvatarPickerSearch", m_URL);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
new file mode 100644
index 0000000..50b83f6
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
@@ -0,0 +1,2251 @@
+/*
+ * 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.Timers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.IO;
+using System.Reflection;
+using System.Text;
+using System.Web;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nini.Config;
+using log4net;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Scenes.Serialization;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Services.Interfaces;
+
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OSDArray = OpenMetaverse.StructuredData.OSDArray;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+using PermissionMask = OpenSim.Framework.PermissionMask;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public delegate void UpLoadedAsset(
+        string assetName, string description, UUID assetID, UUID inventoryItem, UUID parentFolder,
+        byte[] data, string inventoryType, string assetType,
+        int cost, UUID texturesFolder, int nreqtextures, int nreqmeshs, int nreqinstances,
+        bool IsAtestUpload, ref string error, ref int nextOwnerMask, ref int groupMask, ref int everyoneMask);
+
+    public delegate UUID UpdateItem(UUID itemID, byte[] data);
+
+    public delegate void UpdateTaskScript(UUID itemID, UUID primID, bool isScriptRunning, byte[] data, ref ArrayList errors);
+
+    public delegate void NewInventoryItem(UUID userID, InventoryItemBase item, uint cost);
+
+    public delegate void NewAsset(AssetBase asset);
+
+    public delegate UUID ItemUpdatedCallback(UUID userID, UUID itemID, byte[] data);
+
+    public delegate ArrayList TaskScriptUpdatedCallback(UUID userID, UUID itemID, UUID primID,
+                                                   bool isScriptRunning, byte[] data);
+
+    public delegate InventoryCollection FetchInventoryDescendentsCAPS(UUID agentID, UUID folderID, UUID ownerID,
+                                                                          bool fetchFolders, bool fetchItems, int sortOrder, out int version);
+
+    /// <summary>
+    /// XXX Probably not a particularly nice way of allow us to get the scene presence from the scene (chiefly so that
+    /// we can popup a message on the user's client if the inventory service has permanently failed).  But I didn't want
+    /// to just pass the whole Scene into CAPS.
+    /// </summary>
+    public delegate IClientAPI GetClientDelegate(UUID agentID);
+
+    public class BunchOfCaps
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_Scene;
+        private UUID m_AgentID;
+        private Caps m_HostCapsObj;
+        private ModelCost m_ModelCost;
+
+        // private static readonly string m_remoteParcelRequestPath = "0009/";// This is in the LandManagementModule.
+
+        // These are callbacks which will be setup by the scene so that we can update scene data when we
+        // receive capability calls
+        public NewInventoryItem AddNewInventoryItem = null;
+        public NewAsset AddNewAsset = null;
+        public ItemUpdatedCallback ItemUpdatedCall = null;
+        public TaskScriptUpdatedCallback TaskScriptUpdatedCall = null;
+        public FetchInventoryDescendentsCAPS CAPSFetchInventoryDescendents = null;
+        public GetClientDelegate GetClient = null;
+
+        private bool m_persistBakedTextures = false;
+        private IAssetService m_assetService;
+        private bool m_dumpAssetsToFile = false;
+        private string m_regionName;
+
+        private int m_levelUpload = 0;
+
+        private bool m_enableFreeTestUpload = false; // allows "TEST-" prefix hack
+        private bool m_ForceFreeTestUpload = false; // forces all uploads to be test
+
+        private bool m_enableModelUploadTextureToInventory = false; // place uploaded textures also in inventory
+                                                                    // may not be visible till relog
+
+        private bool m_RestrictFreeTestUploadPerms = false; // reduces also the permitions. Needs a creator defined!!
+        private UUID m_testAssetsCreatorID = UUID.Zero;
+
+        private float m_PrimScaleMin = 0.001f;
+
+        private bool m_AllowCapHomeLocation = true;
+        private bool m_AllowCapGroupMemberData = true;
+        private  IUserManagement m_UserManager;
+
+
+        private enum FileAgentInventoryState : int
+        {
+            idle = 0,
+            processRequest = 1,
+            waitUpload = 2,
+            processUpload = 3
+        }
+        private FileAgentInventoryState m_FileAgentInventoryState = FileAgentInventoryState.idle;
+
+        public BunchOfCaps(Scene scene, UUID agentID, Caps caps)
+        {
+            m_Scene = scene;
+            m_AgentID = agentID;
+            m_HostCapsObj = caps;
+
+            // create a model upload cost provider
+            m_ModelCost = new ModelCost(scene);
+
+            m_PrimScaleMin = m_ModelCost.PrimScaleMin;
+
+            IConfigSource config = m_Scene.Config;
+            if (config != null)
+            {
+                IConfig sconfig = config.Configs["Startup"];
+                if (sconfig != null)
+                {
+                    m_levelUpload = sconfig.GetInt("LevelUpload", 0);
+                }
+
+                IConfig appearanceConfig = config.Configs["Appearance"];
+                if (appearanceConfig != null)
+                {
+                    m_persistBakedTextures = appearanceConfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
+                }
+                // economy for model upload
+                IConfig EconomyConfig = config.Configs["Economy"];
+                if (EconomyConfig != null)
+                {
+                    m_ModelCost.Econfig(EconomyConfig);
+
+                    m_enableModelUploadTextureToInventory = EconomyConfig.GetBoolean("MeshModelAllowTextureToInventory", m_enableModelUploadTextureToInventory);
+
+                    m_RestrictFreeTestUploadPerms = EconomyConfig.GetBoolean("m_RestrictFreeTestUploadPerms", m_RestrictFreeTestUploadPerms);
+                    m_enableFreeTestUpload = EconomyConfig.GetBoolean("AllowFreeTestUpload", m_enableFreeTestUpload);
+                    m_ForceFreeTestUpload = EconomyConfig.GetBoolean("ForceFreeTestUpload", m_ForceFreeTestUpload);
+                    string testcreator = EconomyConfig.GetString("TestAssetsCreatorID", "");
+                    if (testcreator != "")
+                    {
+                        UUID id;
+                        UUID.TryParse(testcreator, out id);
+                        if (id != null)
+                            m_testAssetsCreatorID = id;
+                    }
+                }
+
+                IConfig CapsConfig = config.Configs["ClientStack.LindenCaps"];
+                if (CapsConfig != null)
+                {
+                    string homeLocationUrl = CapsConfig.GetString("Cap_HomeLocation", "localhost");
+                    if(homeLocationUrl == String.Empty)
+                        m_AllowCapHomeLocation = false;
+
+                    string GroupMemberDataUrl = CapsConfig.GetString("Cap_GroupMemberData", "localhost");
+                    if(GroupMemberDataUrl == String.Empty)
+                        m_AllowCapGroupMemberData = false;
+                }
+            }
+
+            m_assetService = m_Scene.AssetService;
+            m_regionName = m_Scene.RegionInfo.RegionName;
+            m_UserManager = m_Scene.RequestModuleInterface<IUserManagement>();
+            if (m_UserManager == null)
+                m_log.Error("[CAPS]: GetDisplayNames disabled because user management component not found");
+
+            RegisterHandlers();
+
+            AddNewInventoryItem = m_Scene.AddUploadedInventoryItem;
+            ItemUpdatedCall = m_Scene.CapsUpdateInventoryItemAsset;
+            TaskScriptUpdatedCall = m_Scene.CapsUpdateTaskInventoryScriptAsset;
+            GetClient = m_Scene.SceneGraph.GetControllingClient;
+
+            m_FileAgentInventoryState = FileAgentInventoryState.idle;
+        }
+
+        public string GetNewCapPath()
+        {
+            return  "/CAPS/" + UUID.Random();
+        }
+
+        /// <summary>
+        /// Register a bunch of CAPS http service handlers
+        /// </summary>
+        public void RegisterHandlers()
+        {
+            // this path is also defined elsewhere so keeping it
+            string seedcapsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath +"0000/";
+
+            // the root of all evil path needs to be capsBase + m_requestPath
+            m_HostCapsObj.RegisterHandler(
+                    "SEED", new RestStreamHandler("POST", seedcapsBase, SeedCapRequest, "SEED", null));
+
+//                m_log.DebugFormat(
+//                    "[CAPS]: Registered seed capability {0} for {1}", seedcapsBase, m_HostCapsObj.AgentID);
+
+            RegisterRegionServiceHandlers();
+            RegisterInventoryServiceHandlers();
+            RegisterOtherHandlers();
+        }
+
+        public void RegisterRegionServiceHandlers()
+        {
+            try
+            {
+                //m_capsHandlers["MapLayer"] =
+                //    new LLSDStreamhandler<OSDMapRequest, OSDMapLayerResponse>("POST",
+                //                                                                GetNewCapPath(),
+                //                                                               GetMapLayer);
+
+                IRequestHandler getObjectPhysicsDataHandler = new RestStreamHandler(
+                        "POST", GetNewCapPath(), GetObjectPhysicsData, "GetObjectPhysicsData", null);
+                m_HostCapsObj.RegisterHandler("GetObjectPhysicsData", getObjectPhysicsDataHandler);
+
+                IRequestHandler getObjectCostHandler = new RestStreamHandler(
+                        "POST", GetNewCapPath(), GetObjectCost, "GetObjectCost", null );
+                m_HostCapsObj.RegisterHandler("GetObjectCost", getObjectCostHandler);
+
+                IRequestHandler ResourceCostSelectedHandler = new RestStreamHandler(
+                        "POST", GetNewCapPath(), ResourceCostSelected, "ResourceCostSelected", null);
+                m_HostCapsObj.RegisterHandler("ResourceCostSelected", ResourceCostSelectedHandler);
+
+                IRequestHandler req = new RestStreamHandler(
+                        "POST", GetNewCapPath(), ScriptTaskInventory, "UpdateScript", null);
+                m_HostCapsObj.RegisterHandler("UpdateScriptTaskInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateScriptTask", req);
+
+                if(m_AllowCapHomeLocation)
+                {
+                    IRequestHandler HomeLocationHandler = new RestStreamHandler(
+                        "POST", GetNewCapPath(), HomeLocation, "HomeLocation", null);
+                    m_HostCapsObj.RegisterHandler("HomeLocation", HomeLocationHandler);
+                }
+
+                if(m_AllowCapGroupMemberData)
+                {
+                    IRequestHandler GroupMemberDataHandler = new RestStreamHandler(
+                        "POST", GetNewCapPath(), GroupMemberData, "GroupMemberData", null);
+                    m_HostCapsObj.RegisterHandler("GroupMemberData", GroupMemberDataHandler);
+                }
+
+
+//                IRequestHandler animSetRequestHandler
+//                    = new RestStreamHandler(
+//                        "POST", capsBase + m_animSetTaskUpdatePath, AnimSetTaskInventory, "UpdateScript", null);
+
+//                m_HostCapsObj.RegisterHandler("UpdateAnimSetTaskInventory", animSetRequestHandler);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+        }
+
+        public void RegisterInventoryServiceHandlers()
+        {
+            try
+            {
+                m_HostCapsObj.RegisterHandler("NewFileAgentInventory",
+                    new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDAssetUploadResponse>(
+                        "POST", GetNewCapPath(), NewAgentInventoryRequest, "NewFileAgentInventory", null));
+
+                IRequestHandler req = new RestStreamHandler(
+                        "POST",  GetNewCapPath(), NoteCardAgentInventory, "Update*", null);
+                m_HostCapsObj.RegisterHandler("UpdateNotecardAgentInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateAnimSetAgentInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateScriptAgentInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateScriptAgent", req);
+
+                IRequestHandler UpdateAgentInformationHandler = new RestStreamHandler(
+                        "POST",  GetNewCapPath(), UpdateAgentInformation, "UpdateAgentInformation", null);
+                m_HostCapsObj.RegisterHandler("UpdateAgentInformation", UpdateAgentInformationHandler);
+
+                IRequestHandler CopyInventoryFromNotecardHandler = new RestStreamHandler(
+                        "POST",  GetNewCapPath(), CopyInventoryFromNotecard, "CopyInventoryFromNotecard", null);
+                m_HostCapsObj.RegisterHandler("CopyInventoryFromNotecard", CopyInventoryFromNotecardHandler);
+
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+        }
+
+        public void RegisterOtherHandlers()
+        {
+            try
+            {
+                if (m_UserManager != null)
+                {
+                    IRequestHandler GetDisplayNamesHandler = new RestStreamHandler(
+                        "GET",  GetNewCapPath(), GetDisplayNames, "GetDisplayNames", null);
+                    m_HostCapsObj.RegisterHandler("GetDisplayNames", GetDisplayNamesHandler);
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+        }
+        /// <summary>
+        /// Construct a client response detailing all the capabilities this server can provide.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="httpRequest">HTTP request header object</param>
+        /// <param name="httpResponse">HTTP response header object</param>
+        /// <returns></returns>
+        public string SeedCapRequest(string request, string path, string param,
+                                  IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            m_log.DebugFormat(
+                "[CAPS]: Received SEED caps request in {0} for agent {1}", m_regionName, m_HostCapsObj.AgentID);
+
+            if (!m_HostCapsObj.WaitForActivation())
+                return string.Empty;
+
+            if (!m_Scene.CheckClient(m_HostCapsObj.AgentID, httpRequest.RemoteIPEndPoint))
+            {
+                m_log.WarnFormat(
+                    "[CAPS]: Unauthorized CAPS client {0} from {1}",
+                    m_HostCapsObj.AgentID, httpRequest.RemoteIPEndPoint);
+
+                return string.Empty;
+            }
+
+            OSDArray capsRequested = (OSDArray)OSDParser.DeserializeLLSDXml(request);
+            List<string> validCaps = new List<string>();
+
+            foreach (OSD c in capsRequested)
+                validCaps.Add(c.AsString());
+
+            string result = LLSDHelpers.SerialiseLLSDReply(m_HostCapsObj.GetCapsDetails(true, validCaps));
+
+            //m_log.DebugFormat("[CAPS] CapsRequest {0}", result);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Called by the script task update handler.  Provides a URL to which the client can upload a new asset.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="httpRequest">HTTP request header object</param>
+        /// <param name="httpResponse">HTTP response header object</param>
+        /// <returns></returns>
+        public string ScriptTaskInventory(string request, string path, string param,
+                                          IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            try
+            {
+//                m_log.Debug("[CAPS]: ScriptTaskInventory Request in region: " + m_regionName);
+                //m_log.DebugFormat("[CAPS]: request: {0}, path: {1}, param: {2}", request, path, param);
+
+                Hashtable hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+                LLSDTaskScriptUpdate llsdUpdateRequest = new LLSDTaskScriptUpdate();
+                LLSDHelpers.DeserialiseOSDMap(hash, llsdUpdateRequest);
+
+                string uploaderPath = GetNewCapPath();
+
+                TaskInventoryScriptUpdater uploader =
+                    new TaskInventoryScriptUpdater(
+                        llsdUpdateRequest.item_id,
+                        llsdUpdateRequest.task_id,
+                        llsdUpdateRequest.is_script_running,
+                        uploaderPath,
+                        m_HostCapsObj.HttpListener,
+                        m_dumpAssetsToFile);
+                uploader.OnUpLoad += TaskScriptUpdated;
+
+                m_HostCapsObj.HttpListener.AddStreamHandler(
+                    new BinaryStreamHandler(
+                        "POST", uploaderPath, uploader.uploaderCaps, "TaskInventoryScriptUpdater", null));
+
+                string protocol = "http://";
+
+                if (m_HostCapsObj.SSLCaps)
+                    protocol = "https://";
+
+                string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + uploaderPath;
+
+                LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+                uploadResponse.uploader = uploaderURL;
+                uploadResponse.state = "upload";
+
+                //                m_log.InfoFormat("[CAPS]: " +
+                //                                 "ScriptTaskInventory response: {0}",
+                //                                 LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
+
+                return LLSDHelpers.SerialiseLLSDReply(uploadResponse);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Called when new asset data for an agent inventory item update has been uploaded.
+        /// </summary>
+        /// <param name="itemID">Item to update</param>
+        /// <param name="primID">Prim containing item to update</param>
+        /// <param name="isScriptRunning">Signals whether the script to update is currently running</param>
+        /// <param name="data">New asset data</param>
+        public void TaskScriptUpdated(UUID itemID, UUID primID, bool isScriptRunning, byte[] data, ref ArrayList errors)
+        {
+            if (TaskScriptUpdatedCall != null)
+            {
+                ArrayList e = TaskScriptUpdatedCall(m_HostCapsObj.AgentID, itemID, primID, isScriptRunning, data);
+                foreach (Object item in e)
+                    errors.Add(item);
+            }
+        }
+
+        /// <summary>
+        /// Called when new asset data for an agent inventory item update has been uploaded.
+        /// </summary>
+        /// <param name="itemID">Item to update</param>
+        /// <param name="data">New asset data</param>
+        /// <returns></returns>
+        public UUID ItemUpdated(UUID itemID, byte[] data)
+        {
+            if (ItemUpdatedCall != null)
+            {
+                return ItemUpdatedCall(m_HostCapsObj.AgentID, itemID, data);
+            }
+
+            return UUID.Zero;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="llsdRequest"></param>
+        /// <returns></returns>
+        public LLSDAssetUploadResponse NewAgentInventoryRequest(LLSDAssetUploadRequest llsdRequest)
+        {
+            //m_log.Debug("[CAPS]: NewAgentInventoryRequest Request is: " + llsdRequest.ToString());
+            //m_log.Debug("asset upload request via CAPS" + llsdRequest.inventory_type + " , " + llsdRequest.asset_type);
+
+            // start by getting the client
+            IClientAPI client = null;
+            m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);
+
+            // check current state so we only have one service at a time
+            lock (m_ModelCost)
+            {
+                switch (m_FileAgentInventoryState)
+                {
+                    case FileAgentInventoryState.processRequest:
+                    case FileAgentInventoryState.processUpload:
+                        LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                        resperror.message = "Uploader busy processing previus request";
+                        resperror.identifier = UUID.Zero;
+
+                        LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
+                        errorResponse.uploader = "";
+                        errorResponse.state = "error";
+                        errorResponse.error = resperror;
+                        return errorResponse;
+//                        break;
+                    case FileAgentInventoryState.waitUpload:
+                        // todo stop current uploader server
+                        break;
+                    case FileAgentInventoryState.idle:
+                    default:
+                        break;
+                }
+
+                m_FileAgentInventoryState = FileAgentInventoryState.processRequest;
+            }
+
+            int cost = 0;
+            int nreqtextures = 0;
+            int nreqmeshs= 0;
+            int nreqinstances = 0;
+            bool IsAtestUpload = false;
+
+            string assetName = llsdRequest.name;
+
+            LLSDAssetUploadResponseData meshcostdata = new LLSDAssetUploadResponseData();
+
+            if (llsdRequest.asset_type == "texture" ||
+                llsdRequest.asset_type == "animation" ||
+                llsdRequest.asset_type == "animatn" ||    // this is the asset name actually used by viewers
+                llsdRequest.asset_type == "mesh" ||
+                llsdRequest.asset_type == "sound")
+            {
+                ScenePresence avatar = null;
+                m_Scene.TryGetScenePresence(m_HostCapsObj.AgentID, out avatar);
+
+                // check user level
+                if (avatar != null)
+                {
+                    if (avatar.GodController.UserLevel < m_levelUpload)
+                    {
+                        LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                        resperror.message = "Insufficient permissions to upload";
+                        resperror.identifier = UUID.Zero;
+
+                        LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
+                        errorResponse.uploader = "";
+                        errorResponse.state = "error";
+                        errorResponse.error = resperror;
+                        lock (m_ModelCost)
+                            m_FileAgentInventoryState = FileAgentInventoryState.idle;
+                        return errorResponse;
+                    }
+                }
+
+                // check test upload and funds
+                if (client != null)
+                {
+                    IMoneyModule mm = m_Scene.RequestModuleInterface<IMoneyModule>();
+
+                    int baseCost = 0;
+                    if (mm != null)
+                        baseCost = mm.UploadCharge;
+
+                    string warning = String.Empty;
+
+                    if (llsdRequest.asset_type == "mesh")
+                    {
+                        string error;
+                        int modelcost;
+
+
+                        if (!m_ModelCost.MeshModelCost(llsdRequest.asset_resources, baseCost, out modelcost,
+                            meshcostdata, out error, ref warning))
+                        {
+                            LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                            resperror.message = error;
+                            resperror.identifier = UUID.Zero;
+
+                            LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
+                            errorResponse.uploader = "";
+                            errorResponse.state = "error";
+                            errorResponse.error = resperror;
+
+                            lock (m_ModelCost)
+                                m_FileAgentInventoryState = FileAgentInventoryState.idle;
+                            return errorResponse;
+                        }
+                        cost = modelcost;
+                    }
+                    else
+                    {
+                        cost = baseCost;
+                    }
+
+                    if (cost > 0 && mm != null)
+                    {
+                        // check for test upload
+
+                        if (m_ForceFreeTestUpload) // all are test
+                        {
+                            if (!(assetName.Length > 5 && assetName.StartsWith("TEST-"))) // has normal name lets change it
+                                assetName = "TEST-" + assetName;
+
+                            IsAtestUpload = true;
+                        }
+
+                        else if (m_enableFreeTestUpload) // only if prefixed with "TEST-"
+                        {
+
+                            IsAtestUpload = (assetName.Length > 5 && assetName.StartsWith("TEST-"));
+                        }
+
+
+                        if(IsAtestUpload) // let user know, still showing cost estimation
+                            warning += "Upload will have no cost, for testing purposes only. Other uses are prohibited. Items will not work after 48 hours or on other regions";
+
+                        // check funds
+                        else
+                        {
+                            if (!mm.UploadCovered(client.AgentId, (int)cost))
+                            {
+                                LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                                resperror.message = "Insuficient funds";
+                                resperror.identifier = UUID.Zero;
+
+                                LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
+                                errorResponse.uploader = "";
+                                errorResponse.state = "error";
+                                errorResponse.error = resperror;
+                                lock (m_ModelCost)
+                                    m_FileAgentInventoryState = FileAgentInventoryState.idle;
+                                return errorResponse;
+                            }
+                        }
+                    }
+
+                    if (client != null && warning != String.Empty)
+                        client.SendAgentAlertMessage(warning, true);
+                }
+            }
+
+            string assetDes = llsdRequest.description;
+            UUID newAsset = UUID.Random();
+            UUID newInvItem = UUID.Random();
+            UUID parentFolder = llsdRequest.folder_id;
+            string uploaderPath = GetNewCapPath();
+            UUID texturesFolder = UUID.Zero;
+
+            if(!IsAtestUpload && m_enableModelUploadTextureToInventory)
+                texturesFolder = llsdRequest.texture_folder_id;
+
+            AssetUploader uploader =
+                new AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
+                        llsdRequest.asset_type, uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile, cost,
+                        texturesFolder, nreqtextures, nreqmeshs, nreqinstances, IsAtestUpload,
+                        llsdRequest.next_owner_mask, llsdRequest.group_mask, llsdRequest.everyone_mask);
+
+            m_HostCapsObj.HttpListener.AddStreamHandler(
+                new BinaryStreamHandler(
+                    "POST",
+                    uploaderPath,
+                    uploader.uploaderCaps,
+                    "NewAgentInventoryRequest",
+                    m_HostCapsObj.AgentID.ToString()));
+
+            string protocol = "http://";
+            if (m_HostCapsObj.SSLCaps)
+                protocol = "https://";
+
+            string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + uploaderPath;
+
+            LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+            uploadResponse.uploader = uploaderURL;
+            uploadResponse.state = "upload";
+            uploadResponse.upload_price = (int)cost;
+
+            if (llsdRequest.asset_type == "mesh")
+            {
+                uploadResponse.data = meshcostdata;
+            }
+
+            uploader.OnUpLoad += UploadCompleteHandler;
+
+            lock (m_ModelCost)
+                m_FileAgentInventoryState = FileAgentInventoryState.waitUpload;
+
+            return uploadResponse;
+        }
+
+        /// <summary>
+        /// Convert raw uploaded data into the appropriate asset and item.
+        /// </summary>
+        /// <param name="assetID"></param>
+        /// <param name="inventoryItem"></param>
+        /// <param name="data"></param>
+        public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
+                                          UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
+                                          string assetType, int cost,
+                                          UUID texturesFolder, int nreqtextures, int nreqmeshs, int nreqinstances,
+                                          bool IsAtestUpload, ref string error,
+                                          ref int nextOwnerMask, ref int groupMask, ref int everyoneMask)
+        {
+            lock (m_ModelCost)
+                m_FileAgentInventoryState = FileAgentInventoryState.processUpload;
+
+            m_log.DebugFormat(
+                "[BUNCH OF CAPS]: Uploaded asset {0} for inventory item {1}, inv type {2}, asset type {3}",
+                assetID, inventoryItem, inventoryType, assetType);
+
+            sbyte assType = 0;
+            sbyte inType = 0;
+
+            IClientAPI client = null;
+
+            UUID owner_id = m_HostCapsObj.AgentID;
+            UUID creatorID;
+
+            bool istest = IsAtestUpload && m_enableFreeTestUpload && (cost > 0);
+
+            bool restrictPerms = m_RestrictFreeTestUploadPerms && istest;
+
+            if (istest && m_testAssetsCreatorID != UUID.Zero)
+                creatorID = m_testAssetsCreatorID;
+            else
+                creatorID = owner_id;
+
+            string creatorIDstr = creatorID.ToString();
+
+            IMoneyModule mm = m_Scene.RequestModuleInterface<IMoneyModule>();
+            if (mm != null)
+            {
+                // make sure client still has enougth credit
+                if (!mm.UploadCovered(m_HostCapsObj.AgentID, (int)cost))
+                {
+                    error = "Insufficient funds.";
+                    return;
+                }
+            }
+
+            // strings to types
+            if (inventoryType == "sound")
+            {
+                inType = (sbyte)InventoryType.Sound;
+                assType = (sbyte)AssetType.Sound;
+            }
+            else if (inventoryType == "snapshot")
+            {
+                inType = (sbyte)InventoryType.Snapshot;
+            }
+            else if (inventoryType == "animation")
+            {
+                inType = (sbyte)InventoryType.Animation;
+                assType = (sbyte)AssetType.Animation;
+            }
+            else if (inventoryType == "animset")
+            {
+                inType = (sbyte)CustomInventoryType.AnimationSet;
+                assType = (sbyte)CustomAssetType.AnimationSet;
+                m_log.Debug("got animset upload request");
+            }
+            else if (inventoryType == "wearable")
+            {
+                inType = (sbyte)InventoryType.Wearable;
+                switch (assetType)
+                {
+                    case "bodypart":
+                        assType = (sbyte)AssetType.Bodypart;
+                        break;
+                    case "clothing":
+                        assType = (sbyte)AssetType.Clothing;
+                        break;
+                }
+            }
+            else if (inventoryType == "object")
+            {
+                if (assetType == "mesh") // this code for now is for mesh models uploads only
+                {
+                    inType = (sbyte)InventoryType.Object;
+                    assType = (sbyte)AssetType.Object;
+
+                    List<Vector3> positions = new List<Vector3>();
+                    List<Quaternion> rotations = new List<Quaternion>();
+                    OSDMap request = (OSDMap)OSDParser.DeserializeLLSDXml(data);
+
+                    // compare and get updated information
+/* does nothing still we do need something to avoid special viewer to upload something diferent from the cost estimation
+                    bool mismatchError = true;
+
+                    while (mismatchError)
+                    {
+                        mismatchError = false;
+                    }
+
+                    if (mismatchError)
+                    {
+                        error = "Upload and fee estimation information don't match";
+                        lock (m_ModelCost)
+                            m_FileAgentInventoryState = FileAgentInventoryState.idle;
+
+                        return;
+                    }
+*/
+                    OSDArray instance_list = (OSDArray)request["instance_list"];
+                    OSDArray mesh_list = (OSDArray)request["mesh_list"];
+                    OSDArray texture_list = (OSDArray)request["texture_list"];
+                    SceneObjectGroup grp = null;
+
+                    // create and store texture assets
+                    bool doTextInv = (!istest && m_enableModelUploadTextureToInventory &&
+                                    texturesFolder != UUID.Zero);
+
+
+                    List<UUID> textures = new List<UUID>();
+
+
+//                    if (doTextInv)
+                        m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);
+
+                    if(client == null) // don't put textures in inventory if there is no client
+                        doTextInv = false;
+
+                    for (int i = 0; i < texture_list.Count; i++)
+                    {
+                        AssetBase textureAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Texture, creatorIDstr);
+                        textureAsset.Data = texture_list[i].AsBinary();
+                        if (istest)
+                            textureAsset.Local = true;
+                        m_assetService.Store(textureAsset);
+                        textures.Add(textureAsset.FullID);
+
+                        if (doTextInv)
+                        {
+                            string name = assetName;
+                            if (name.Length > 25)
+                                name = name.Substring(0, 24);
+                            name += "_Texture#" + i.ToString();
+                            InventoryItemBase texitem = new InventoryItemBase();
+                            texitem.Owner = m_HostCapsObj.AgentID;
+                            texitem.CreatorId = creatorIDstr;
+                            texitem.CreatorData = String.Empty;
+                            texitem.ID = UUID.Random();
+                            texitem.AssetID = textureAsset.FullID;
+                            texitem.Description = "mesh model texture";
+                            texitem.Name = name;
+                            texitem.AssetType = (int)AssetType.Texture;
+                            texitem.InvType = (int)InventoryType.Texture;
+                            texitem.Folder = texturesFolder;
+
+                            texitem.CurrentPermissions
+                                = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer | PermissionMask.Export);
+
+                            texitem.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                            texitem.EveryOnePermissions = 0;
+                            texitem.NextPermissions = (uint)PermissionMask.All;
+                            texitem.CreationDate = Util.UnixTimeSinceEpoch();
+
+                            m_Scene.AddInventoryItem(client, texitem);
+                            texitem = null;
+                        }
+                    }
+
+                    // create and store meshs assets
+                    List<UUID> meshAssets = new List<UUID>();
+                    List<bool> meshAvatarSkeletons = new List<bool>();
+                    List<bool> meshAvatarColliders = new List<bool>();
+
+                    bool curAvSkeleton;
+                    bool curAvCollider;
+                    for (int i = 0; i < mesh_list.Count; i++)
+                    {
+                        curAvSkeleton = false;
+                        curAvCollider = false;
+
+                        // we do need to parse the mesh now
+                        OSD osd = OSDParser.DeserializeLLSDBinary(mesh_list[i]);
+                        if (osd is OSDMap)
+                        {
+                            OSDMap mosd = (OSDMap)osd;
+                            if (mosd.ContainsKey("skeleton"))
+                            {
+                                OSDMap skeleton = (OSDMap)mosd["skeleton"];
+                                int sksize = skeleton["size"].AsInteger();
+                                if (sksize > 0)
+                                    curAvSkeleton = true;
+                            }
+                        }
+
+                        AssetBase meshAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Mesh, creatorIDstr);
+                        meshAsset.Data = mesh_list[i].AsBinary();
+                        if (istest)
+                            meshAsset.Local = true;
+                        m_assetService.Store(meshAsset);
+                        meshAssets.Add(meshAsset.FullID);
+                        meshAvatarSkeletons.Add(curAvSkeleton);
+                        meshAvatarColliders.Add(curAvCollider);
+
+                        // test code
+                        if (curAvSkeleton && client != null)
+                        {
+                            string name = assetName;
+                            if (name.Length > 25)
+                                name = name.Substring(0, 24);
+                            name += "_Mesh#" + i.ToString();
+                            InventoryItemBase meshitem = new InventoryItemBase();
+                            meshitem.Owner = m_HostCapsObj.AgentID;
+                            meshitem.CreatorId = creatorIDstr;
+                            meshitem.CreatorData = String.Empty;
+                            meshitem.ID = UUID.Random();
+                            meshitem.AssetID = meshAsset.FullID;
+                            meshitem.Description = "mesh ";
+                            meshitem.Name = name;
+                            meshitem.AssetType = (int)AssetType.Mesh;
+                            meshitem.InvType = (int)InventoryType.Mesh;
+                            //                            meshitem.Folder = UUID.Zero; // send to default
+
+                            meshitem.Folder = parentFolder; // dont let it go to folder Meshes that viewers dont show
+
+                            // If we set PermissionMask.All then when we rez the item the next permissions will replace the current
+                            // (owner) permissions.  This becomes a problem if next permissions are changed.
+                            meshitem.CurrentPermissions
+                                = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
+
+                            meshitem.BasePermissions = (uint)PermissionMask.All;
+                            meshitem.EveryOnePermissions = 0;
+                            meshitem.NextPermissions = (uint)PermissionMask.All;
+                            meshitem.CreationDate = Util.UnixTimeSinceEpoch();
+
+                            m_Scene.AddInventoryItem(client, meshitem);
+                            meshitem = null;
+                        }
+                    }
+
+                    int skipedMeshs = 0;
+                    // build prims from instances
+                    for (int i = 0; i < instance_list.Count; i++)
+                    {
+                        OSDMap inner_instance_list = (OSDMap)instance_list[i];
+
+                        // skip prims that are 2 small
+                        Vector3 scale = inner_instance_list["scale"].AsVector3();
+
+                        if (scale.X < m_PrimScaleMin || scale.Y < m_PrimScaleMin || scale.Z < m_PrimScaleMin)
+                        {
+                            skipedMeshs++;
+                            continue;
+                        }
+
+                        OSDArray face_list = (OSDArray)inner_instance_list["face_list"];
+
+                        PrimitiveBaseShape pbs = null;
+                        if (inner_instance_list.ContainsKey("mesh")) // seems to happen always but ...
+                        {
+                            int meshindx = inner_instance_list["mesh"].AsInteger();
+                            if (meshAssets.Count > meshindx)
+                                pbs = PrimitiveBaseShape.CreateMesh(face_list.Count, meshAssets[meshindx]);
+                        }
+                        if(pbs == null) // fallback
+                            pbs = PrimitiveBaseShape.CreateBox();
+
+                        Primitive.TextureEntry textureEntry
+                            = new Primitive.TextureEntry(Primitive.TextureEntry.WHITE_TEXTURE);
+
+                        for (uint face = 0; face < face_list.Count; face++)
+                        {
+                            OSDMap faceMap = (OSDMap)face_list[(int)face];
+
+                            Primitive.TextureEntryFace f = textureEntry.CreateFace(face); //clone the default
+                            if (faceMap.ContainsKey("fullbright"))
+                                f.Fullbright = faceMap["fullbright"].AsBoolean();
+                            if (faceMap.ContainsKey("diffuse_color"))
+                                f.RGBA = faceMap["diffuse_color"].AsColor4();
+
+                            int textureNum = faceMap["image"].AsInteger();
+                            float imagerot = faceMap["imagerot"].AsInteger();
+                            float offsets = (float)faceMap["offsets"].AsReal();
+                            float offsett = (float)faceMap["offsett"].AsReal();
+                            float scales = (float)faceMap["scales"].AsReal();
+                            float scalet = (float)faceMap["scalet"].AsReal();
+
+                            if (imagerot != 0)
+                                f.Rotation = imagerot;
+
+                            if (offsets != 0)
+                                f.OffsetU = offsets;
+
+                            if (offsett != 0)
+                                f.OffsetV = offsett;
+
+                            if (scales != 0)
+                                f.RepeatU = scales;
+
+                            if (scalet != 0)
+                                f.RepeatV = scalet;
+
+                            if (textures.Count > textureNum)
+                                f.TextureID = textures[textureNum];
+ 
+                            textureEntry.FaceTextures[face] = f;
+                        }
+                        pbs.TextureEntry = textureEntry.GetBytes();
+
+                        Vector3 position = inner_instance_list["position"].AsVector3();
+                        Quaternion rotation = inner_instance_list["rotation"].AsQuaternion();
+
+                        // for now viwers do send fixed defaults
+                        // but this may change
+//                        int physicsShapeType = inner_instance_list["physics_shape_type"].AsInteger();
+                        byte physicsShapeType = (byte)PhysShapeType.convex; // default is simple convex
+//                        int material = inner_instance_list["material"].AsInteger();
+                        byte material = (byte)Material.Wood;
+
+                        SceneObjectPart prim
+                            = new SceneObjectPart(owner_id, pbs, position, Quaternion.Identity, Vector3.Zero);
+
+                        prim.Scale = scale;
+                        rotations.Add(rotation);
+                        positions.Add(position);
+                        prim.UUID = UUID.Random();
+                        prim.CreatorID = creatorID;
+                        prim.OwnerID = owner_id;
+                        prim.GroupID = UUID.Zero;
+                        prim.LastOwnerID = creatorID;
+                        prim.RezzerID = creatorID;
+                        prim.CreationDate = Util.UnixTimeSinceEpoch();
+
+                        if (grp == null)
+                            prim.Name = assetName;
+                        else
+                            prim.Name = assetName + "#" + i.ToString();
+
+                        prim.EveryoneMask = 0;
+                        prim.GroupMask = 0;
+
+                        if (restrictPerms)
+                        {
+                            prim.BaseMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                            prim.OwnerMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                            prim.NextOwnerMask = 0;
+                        }
+                        else
+                        {
+                            prim.BaseMask = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                            prim.OwnerMask = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                            prim.GroupMask = prim.BaseMask & (uint)groupMask;
+                            prim.EveryoneMask = prim.BaseMask & (uint)everyoneMask;
+                            prim.NextOwnerMask = prim.BaseMask & (uint)nextOwnerMask;
+                            // If the viewer gives us bogus permissions, revert to the SL
+                            // default of transfer only.
+                            if ((prim.NextOwnerMask & (uint)PermissionMask.All) == 0)
+                                prim.NextOwnerMask = (uint)PermissionMask.Transfer;
+                        }
+
+                        if(istest)
+                            prim.Description = "For testing only. Other uses are prohibited";
+                        else
+                            prim.Description = "";
+
+                        prim.Material = material;
+                        prim.PhysicsShapeType = physicsShapeType;
+
+//                    prim.BaseMask = (uint)base_mask;
+//                    prim.EveryoneMask = (uint)everyone_mask;
+//                    prim.GroupMask = (uint)group_mask;
+//                    prim.NextOwnerMask = (uint)next_owner_mask;
+//                    prim.OwnerMask = (uint)owner_mask;
+
+                        if (grp == null)
+                        {
+                            grp = new SceneObjectGroup(prim);
+                            grp.LastOwnerID = creatorID;
+                            grp.RezzerID = creatorID;
+                        }
+                        else
+                            grp.AddPart(prim);
+                    }
+
+                    Vector3 rootPos = positions[0];
+
+                    if (grp.Parts.Length > 1)
+                    {
+                        // Fix first link number
+                        grp.RootPart.LinkNum++;
+
+                        Quaternion rootRotConj = Quaternion.Conjugate(rotations[0]);
+                        Quaternion tmprot;
+                        Vector3 offset;
+
+                        // fix children rotations and positions
+                        for (int i = 1; i < rotations.Count; i++)
+                        {
+                            tmprot = rotations[i];
+                            tmprot = rootRotConj * tmprot;
+
+                            grp.Parts[i].RotationOffset = tmprot;
+
+                            offset = positions[i] - rootPos;
+
+                            offset *= rootRotConj;
+                            grp.Parts[i].OffsetPosition = offset;
+                        }
+
+                        grp.AbsolutePosition = rootPos;
+                        grp.UpdateGroupRotationR(rotations[0]);
+                    }
+                    else
+                    {
+                        grp.AbsolutePosition = rootPos;
+                        grp.UpdateGroupRotationR(rotations[0]);
+                    }
+
+                    data = ASCIIEncoding.ASCII.GetBytes(SceneObjectSerializer.ToOriginalXmlFormat(grp));
+                }
+
+                else // not a mesh model
+                {
+                    m_log.ErrorFormat("[CAPS Asset Upload] got unsuported assetType for object upload");
+                    return;
+                }
+            }
+
+            AssetBase asset;
+            asset = new AssetBase(assetID, assetName, assType, creatorIDstr);
+            asset.Data = data;
+            if (istest)
+                asset.Local = true;
+            if (AddNewAsset != null)
+                AddNewAsset(asset);
+            else if (m_assetService != null)
+                m_assetService.Store(asset);
+
+            InventoryItemBase item = new InventoryItemBase();
+            item.Owner = m_HostCapsObj.AgentID;
+            item.CreatorId = creatorIDstr;
+            item.CreatorData = String.Empty;
+            item.ID = inventoryItem;
+            item.AssetID = asset.FullID;
+            if (istest)
+            {
+                item.Description = "For testing only. Other uses are prohibited";
+                item.Flags = (uint) (InventoryItemFlags.SharedSingleReference);
+            }
+            else
+                item.Description = assetDescription;
+            item.Name = assetName;
+            item.AssetType = assType;
+            item.InvType = inType;
+            item.Folder = parentFolder;
+
+            // If we set PermissionMask.All then when we rez the item the next permissions will replace the current
+            // (owner) permissions.  This becomes a problem if next permissions are changed.
+
+            if (inType == (sbyte)CustomInventoryType.AnimationSet)
+            {
+                AnimationSet.setCreateItemPermitions(item);
+            }
+
+            else if (restrictPerms)
+            {
+                item.BasePermissions = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                item.CurrentPermissions = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                item.GroupPermissions = 0;
+                item.EveryOnePermissions = 0;
+                item.NextPermissions = 0;
+            }
+            else
+            {
+                item.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                item.CurrentPermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                item.GroupPermissions = item.BasePermissions & (uint)groupMask;
+                item.EveryOnePermissions = item.BasePermissions & (uint)everyoneMask;
+                item.NextPermissions = item.BasePermissions & (uint)nextOwnerMask;
+                if ((item.NextPermissions & (uint)PermissionMask.All) == 0)
+                    item.NextPermissions = (uint)PermissionMask.Transfer;
+            }
+
+            item.CreationDate = Util.UnixTimeSinceEpoch();
+
+            everyoneMask = (int)item.EveryOnePermissions;
+            groupMask = (int)item.GroupPermissions;
+            nextOwnerMask = (int)item.NextPermissions;
+
+            m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);
+
+            if (AddNewInventoryItem != null)
+            {
+                if (istest)
+                {
+                    m_Scene.AddInventoryItem(client, item);
+/*
+                    AddNewInventoryItem(m_HostCapsObj.AgentID, item, 0);
+                    if (client != null)
+                        client.SendAgentAlertMessage("Upload will have no cost, for personal test purposes only. Other uses are forbiden. Items may not work on a another region" , true);
+ */
+                }
+                else
+                {
+                    AddNewInventoryItem(m_HostCapsObj.AgentID, item, (uint)cost);
+//                    if (client != null)
+//                    {
+//                        // let users see anything..  i don't so far
+//                        string str;
+//                        if (cost > 0)
+//                            // dont remember where is money unit name to put here
+//                            str = "Upload complete. charged " + cost.ToString() + "$";
+//                        else
+//                            str = "Upload complete";
+//                        client.SendAgentAlertMessage(str, true);
+//                    }
+                }
+            }
+
+            lock (m_ModelCost)
+                m_FileAgentInventoryState = FileAgentInventoryState.idle;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="mapReq"></param>
+        /// <returns></returns>
+        public LLSDMapLayerResponse GetMapLayer(LLSDMapRequest mapReq)
+        {
+            m_log.Debug("[CAPS]: MapLayer Request in region: " + m_regionName);
+            LLSDMapLayerResponse mapResponse = new LLSDMapLayerResponse();
+            mapResponse.LayerData.Array.Add(GetOSDMapLayerResponse());
+            return mapResponse;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected static OSDMapLayer GetOSDMapLayerResponse()
+        {
+            OSDMapLayer mapLayer = new OSDMapLayer();
+            mapLayer.Right = 5000;
+            mapLayer.Top = 5000;
+            mapLayer.ImageID = new UUID("00000000-0000-1111-9999-000000000006");
+
+            return mapLayer;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string RequestTexture(string request, string path, string param)
+        {
+            m_log.Debug("texture request " + request);
+            // Needs implementing (added to remove compiler warning)
+            return String.Empty;
+        }
+
+
+        /// <summary>
+        /// Called by the notecard update handler.  Provides a URL to which the client can upload a new asset.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string NoteCardAgentInventory(string request, string path, string param,
+                                             IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            //m_log.Debug("[CAPS]: NoteCardAgentInventory Request in region: " + m_regionName + "\n" + request);
+            //m_log.Debug("[CAPS]: NoteCardAgentInventory Request is: " + request);
+
+            //OpenMetaverse.StructuredData.OSDMap hash = (OpenMetaverse.StructuredData.OSDMap)OpenMetaverse.StructuredData.LLSDParser.DeserializeBinary(Utils.StringToBytes(request));
+            Hashtable hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+            LLSDItemUpdate llsdRequest = new LLSDItemUpdate();
+            LLSDHelpers.DeserialiseOSDMap(hash, llsdRequest);
+
+            string uploaderPath = GetNewCapPath();
+
+            ItemUpdater uploader =
+                new ItemUpdater(llsdRequest.item_id, uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
+            uploader.OnUpLoad += ItemUpdated;
+
+            m_HostCapsObj.HttpListener.AddStreamHandler(
+                new BinaryStreamHandler(
+                    "POST", uploaderPath, uploader.uploaderCaps, "NoteCardAgentInventory", null));
+
+            string protocol = "http://";
+
+            if (m_HostCapsObj.SSLCaps)
+                protocol = "https://";
+
+            string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + uploaderPath;
+
+            LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+            uploadResponse.uploader = uploaderURL;
+            uploadResponse.state = "upload";
+
+            //            m_log.InfoFormat("[CAPS]: " +
+            //                             "NoteCardAgentInventory response: {0}",
+            //                             LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
+
+            return LLSDHelpers.SerialiseLLSDReply(uploadResponse);
+        }
+
+        /// <summary>
+        /// Called by the CopyInventoryFromNotecard caps handler.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        public string CopyInventoryFromNotecard(string request, string path, string param,
+                                             IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            Hashtable response = new Hashtable();
+            response["int_response_code"] = 404;
+            response["content_type"] = "text/plain";
+            response["keepalive"] = false;
+            response["str_response_string"] = "";
+
+            try
+            {
+                OSDMap content = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+                UUID objectID = content["object-id"].AsUUID();
+                UUID notecardID = content["notecard-id"].AsUUID();
+                UUID folderID = content["folder-id"].AsUUID();
+                UUID itemID = content["item-id"].AsUUID();
+
+                //  m_log.InfoFormat("[CAPS]: CopyInventoryFromNotecard, FolderID:{0}, ItemID:{1}, NotecardID:{2}, ObjectID:{3}", folderID, itemID, notecardID, objectID);
+
+                if (objectID != UUID.Zero)
+                {
+                    SceneObjectPart part = m_Scene.GetSceneObjectPart(objectID);
+                    if (part != null)
+                    {
+//                        TaskInventoryItem taskItem = part.Inventory.GetInventoryItem(notecardID);
+                        if (!m_Scene.Permissions.CanCopyObjectInventory(notecardID, objectID, m_HostCapsObj.AgentID))
+                        {
+                            return LLSDHelpers.SerialiseLLSDReply(response);
+                        }
+                    }
+                }
+
+                InventoryItemBase item = null;
+                InventoryItemBase copyItem = null;
+                IClientAPI client = null;
+
+                m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);
+                item = m_Scene.InventoryService.GetItem(m_HostCapsObj.AgentID, itemID);
+                if (item != null)
+                {
+                    string message;
+                    copyItem = m_Scene.GiveInventoryItem(m_HostCapsObj.AgentID, item.Owner, itemID, folderID, out message);
+                    if (copyItem != null && client != null)
+                    {
+                        m_log.InfoFormat("[CAPS]: CopyInventoryFromNotecard, ItemID:{0}, FolderID:{1}", copyItem.ID, copyItem.Folder);
+                        client.SendBulkUpdateInventory(copyItem);
+                    }
+                }
+                else
+                {
+                    m_log.ErrorFormat("[CAPS]: CopyInventoryFromNotecard - Failed to retrieve item {0} from notecard {1}", itemID, notecardID);
+                    if (client != null)
+                        client.SendAlertMessage("Failed to retrieve item");
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[CAPS]: CopyInventoryFromNotecard : {0}", e.ToString());
+            }
+
+            response["int_response_code"] = 200;
+            return LLSDHelpers.SerialiseLLSDReply(response);
+        }
+
+        public string GetObjectPhysicsData(string request, string path,
+                string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+            OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            OSDMap resp = new OSDMap();
+            OSDArray object_ids = (OSDArray)req["object_ids"];
+
+            for (int i = 0 ; i < object_ids.Count ; i++)
+            {
+                UUID uuid = object_ids[i].AsUUID();
+
+                SceneObjectPart obj = m_Scene.GetSceneObjectPart(uuid);
+                if (obj != null)
+                {
+                    OSDMap object_data = new OSDMap();
+
+                    object_data["PhysicsShapeType"] = obj.PhysicsShapeType;
+                    object_data["Density"] = obj.Density;
+                    object_data["Friction"] = obj.Friction;
+                    object_data["Restitution"] = obj.Restitution;
+                    object_data["GravityMultiplier"] = obj.GravityModifier;
+
+                    resp[uuid.ToString()] = object_data;
+                }
+            }
+
+            string response = OSDParser.SerializeLLSDXmlString(resp);
+            return response;
+        }
+
+        public string GetObjectCost(string request, string path,
+                string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+            OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            OSDMap resp = new OSDMap();
+
+            OSDArray object_ids = (OSDArray)req["object_ids"];
+
+            for (int i = 0; i < object_ids.Count; i++)
+            {
+                UUID uuid = object_ids[i].AsUUID();
+
+                SceneObjectPart part = m_Scene.GetSceneObjectPart(uuid);
+                SceneObjectGroup grp = null;
+                if (part != null)
+                    grp = part.ParentGroup;
+                if (grp != null)
+                {
+                    float linksetCost;
+                    float linksetPhysCost;
+                    float partCost;
+                    float partPhysCost;
+
+                    grp.GetResourcesCosts(part,out linksetCost,out linksetPhysCost,out partCost,out partPhysCost);
+
+                    OSDMap object_data = new OSDMap();
+                    object_data["linked_set_resource_cost"] = linksetCost;
+                    object_data["resource_cost"] = partCost;
+                    object_data["physics_cost"] = partPhysCost;
+                    object_data["linked_set_physics_cost"] = linksetPhysCost;
+                    object_data["resource_limiting_type"] = "legacy";
+                    resp[uuid.ToString()] = object_data;
+                }
+            }
+            if(resp.Count == 0)
+            {
+                OSDMap object_data = new OSDMap();
+                object_data["linked_set_resource_cost"] = 0;
+                object_data["resource_cost"] = 0;
+                object_data["physics_cost"] = 0;
+                object_data["linked_set_physics_cost"] = 0;
+                resp[UUID.Zero.ToString()] = object_data;
+            }
+            string response = OSDParser.SerializeLLSDXmlString(resp);
+            return response;
+        }
+
+        public string ResourceCostSelected(string request, string path,
+                string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+            OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            OSDMap resp = new OSDMap();
+
+
+            float phys=0;
+            float stream=0;
+            float simul=0;
+
+            if (req.ContainsKey("selected_roots"))
+            {
+                OSDArray object_ids = (OSDArray)req["selected_roots"];
+
+                // should go by SOG suming costs for all parts
+                // ll v3 works ok with several objects select we get the list and adds ok
+                // FS calls per object so results are wrong guess fs bug
+                for (int i = 0; i < object_ids.Count; i++)
+                {
+                    UUID uuid = object_ids[i].AsUUID();
+                    float Physc;
+                    float simulc;
+                    float streamc;
+
+                    SceneObjectGroup grp = m_Scene.GetGroupByPrim(uuid);
+                    if (grp != null)
+                    {
+                        grp.GetSelectedCosts(out Physc, out streamc, out simulc);
+                        phys += Physc;
+                        stream += streamc;
+                        simul += simulc;
+                    }
+                }
+            }
+            else if (req.ContainsKey("selected_prims"))
+            {
+                OSDArray object_ids = (OSDArray)req["selected_prims"];
+
+                // don't see in use in any of the 2 viewers
+                // guess it should be for edit linked but... nothing
+                // should go to SOP per part
+                for (int i = 0; i < object_ids.Count; i++)
+                {
+                    UUID uuid = object_ids[i].AsUUID();
+
+                    SceneObjectPart part = m_Scene.GetSceneObjectPart(uuid);
+                    if (part != null)
+                    {
+                        phys += part.PhysicsCost;
+                        stream += part.StreamingCost;
+                        simul += part.SimulationCost;
+                    }
+                }
+            }
+
+            OSDMap object_data = new OSDMap();
+
+            object_data["physics"] = phys;
+            object_data["streaming"] = stream;
+            object_data["simulation"] = simul;
+
+            resp["selected"] = object_data;
+//            resp["transaction_id"] = "undef";
+            string response = OSDParser.SerializeLLSDXmlString(resp);
+            return response;
+        }
+
+        public string UpdateAgentInformation(string request, string path,
+                string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+//            OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            OSDMap resp = new OSDMap();
+
+            OSDMap accessPrefs = new OSDMap();
+            accessPrefs["max"] = "A";
+
+            resp["access_prefs"] = accessPrefs;
+
+            string response = OSDParser.SerializeLLSDXmlString(resp);
+            return response;
+        }
+
+        public bool OSDMapTOVector3(OSDMap map, out Vector3 v)
+        {
+            v = Vector3.Zero;
+            if(!map.ContainsKey("X"))
+                return false;
+            if(!map.ContainsKey("Y"))
+                return false;
+            if(!map.ContainsKey("Z"))
+                return false;
+            v.X = (float)map["X"].AsReal();
+            v.Y = (float)map["Y"].AsReal();
+            v.Z = (float)map["Z"].AsReal();
+            return true;
+        }
+
+        public string HomeLocation(string request, string path, string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+            OSDMap resp = new OSDMap();
+
+            resp["success"] = "false";
+
+
+            bool fail = true;
+            string message = "Set Home request failed";
+            int locationID = 1;
+            Vector3 pos = Vector3.Zero;
+            Vector3 lookAt = Vector3.Zero;
+
+            IClientAPI client = null;
+            ScenePresence sp;
+
+            while(true)
+            {
+                if(m_Scene.GridUserService == null)
+                    break;
+
+                if(m_Scene.UserManagementModule == null)
+                    break;
+
+                m_Scene.TryGetScenePresence(m_AgentID, out sp);
+                if(sp == null || sp.IsChildAgent || sp.IsDeleted)
+                    break;
+
+                if(sp.IsInTransit && !sp.IsInLocalTransit)
+                    break;
+
+                client = sp.ControllingClient;
+
+                if(!m_Scene.UserManagementModule.IsLocalGridUser(m_AgentID))
+                    break;
+
+                OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+                if(!req.ContainsKey("HomeLocation"))
+                    break;
+
+                OSDMap HLocation = (OSDMap)req["HomeLocation"];
+                if(!HLocation.ContainsKey("LocationPos"))
+                    break;
+                if(!HLocation.ContainsKey("LocationLookAt"))
+                    break;
+
+                locationID = HLocation["LocationId"].AsInteger();
+
+                if(!OSDMapTOVector3((OSDMap)HLocation["LocationPos"], out pos))
+                    break;
+
+                if(!OSDMapTOVector3((OSDMap)HLocation["LocationLookAt"], out lookAt))
+                    break;
+
+                ILandObject land = m_Scene.LandChannel.GetLandObject(pos);
+                if(land == null)
+                    break;
+
+                ulong gpowers = client.GetGroupPowers(land.LandData.GroupID);
+                SceneObjectGroup telehub = null;
+                if (m_Scene.RegionInfo.RegionSettings.TelehubObject != UUID.Zero)
+                // Does the telehub exist in the scene?
+                    telehub = m_Scene.GetSceneObjectGroup(m_Scene.RegionInfo.RegionSettings.TelehubObject);
+
+                if (!m_Scene.Permissions.IsAdministrator(m_AgentID) && // (a) gods and land managers can set home
+                    !m_Scene.Permissions.IsGod(m_AgentID) &&
+                    m_AgentID != land.LandData.OwnerID && // (b) land owners can set home
+                    // (c) members of the land-associated group in roles that can set home
+                    ((gpowers & (ulong)GroupPowers.AllowSetHome) != (ulong)GroupPowers.AllowSetHome) &&
+                    // (d) parcels with telehubs can be the home of anyone
+                    (telehub == null || !land.ContainsPoint((int)telehub.AbsolutePosition.X, (int)telehub.AbsolutePosition.Y)))
+                {
+                    message = "You are not allowed to set your home location in this parcel.";
+                    break;
+                }
+
+                string userId;
+                UUID test;
+                if (!m_Scene.UserManagementModule.GetUserUUI(m_AgentID, out userId))
+                {
+                    message = "Set Home request failed. (User Lookup)";
+                    break;
+                }
+
+                if (!UUID.TryParse(userId, out test))
+                {
+                    message = "Set Home request failed. (HG visitor)";
+                    break;
+                }
+
+                if (m_Scene.GridUserService.SetHome(userId, land.RegionUUID, pos, lookAt))
+                    fail = false;
+
+                break;
+            }
+
+            string response;
+
+            if(fail)
+            {
+                if(client != null)
+                    client.SendAlertMessage(message);
+                response = OSDParser.SerializeLLSDXmlString(resp);
+                return response;
+            }
+
+            // so its http but still needs a udp reply to inform user? crap :p
+            if(client != null)
+               client.SendAlertMessage("Home position set.","HomePositionSet");
+
+            resp["success"] = "true";
+            OSDMap homeloc = new OSDMap();
+            OSDMap homelocpos = new OSDMap();
+            // for some odd reason viewers send pos as reals but read as integer
+            homelocpos["X"] = new OSDReal(pos.X);
+            homelocpos["Y"] = new OSDReal(pos.Y);
+            homelocpos["Z"] = new OSDReal(pos.Z);
+            homeloc["LocationPos"] = homelocpos;
+
+            resp["HomeLocation"] = homeloc;
+
+            response = OSDParser.SerializeLLSDXmlString(resp);
+            return response;
+        }
+
+        private static int CompareRolesByMembersDesc(GroupRolesData x, GroupRolesData y)
+        {
+            return -(x.Members.CompareTo(y.Members));
+        }
+
+        public string GroupMemberData(string request, string path, string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+            OSDMap resp = new OSDMap();
+
+            string response;
+
+            bool fail = true;
+            IClientAPI client = null;
+            ScenePresence sp;
+            IGroupsModule m_GroupsModule;
+            UUID groupID = UUID.Zero;
+
+            while(true)
+            {
+                m_GroupsModule = m_Scene.RequestModuleInterface<IGroupsModule>();
+                if(m_GroupsModule == null)
+                    break;
+
+                m_Scene.TryGetScenePresence(m_AgentID, out sp);
+                if(sp == null || sp.IsChildAgent || sp.IsDeleted)
+                    break;
+                
+                if(sp.IsInTransit && !sp.IsInLocalTransit)
+                    break;
+
+                client = sp.ControllingClient;
+
+                OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+                if(!req.ContainsKey("group_id"))
+                    break;
+
+                groupID = req["group_id"].AsUUID();
+                if(groupID == UUID.Zero)
+                    break;
+
+                List<GroupRolesData> roles = m_GroupsModule.GroupRoleDataRequest(client, groupID);
+                if(roles == null || roles.Count == 0)
+                    break;
+
+                List<GroupMembersData> members = m_GroupsModule.GroupMembersRequest(client, groupID);
+                if(members == null || members.Count == 0)
+                    break;
+
+                int memberCount = members.Count;
+
+                Dictionary<string,int> titles = new Dictionary<string,int>();
+                int i = 0;
+
+                ulong defaultPowers = 0;
+
+
+                // build titles array and index
+                roles.Sort(CompareRolesByMembersDesc);
+
+                OSDArray osdtitles = new OSDArray();
+                foreach(GroupRolesData grd in roles)
+                {
+                    if(grd.Title == null)
+                        continue;
+                    string title = grd.Title;
+                    if(i==0)
+                        defaultPowers = grd.Powers;
+
+                    if(!titles.ContainsKey(title))
+                    {
+                        titles[title] = i++;
+                        osdtitles.Add(new OSDString(title));
+                    }
+                }
+
+                if(titles.Count == 0)
+                    break;
+
+                OSDMap osdmembers = new OSDMap();
+                foreach(GroupMembersData gmd in members)
+                {
+                    OSDMap m = new OSDMap();
+                    if(gmd.OnlineStatus != null && gmd.OnlineStatus != "")
+                        m["last_login"] = new OSDString(gmd.OnlineStatus);
+                    if(gmd.AgentPowers != defaultPowers)
+                        m["powers"] = new OSDString((gmd.AgentPowers).ToString("X"));
+                    if(gmd.Title != null && titles.ContainsKey(gmd.Title) && titles[gmd.Title] != 0)
+                        m["title"] = new OSDInteger(titles[gmd.Title]);
+                    if(gmd.IsOwner)
+                        m["owner"] = new OSDString("true");
+                    if(gmd.Contribution != 0)
+                        m["donated_square_meters"] = new OSDInteger(gmd.Contribution);
+
+                    osdmembers[(gmd.AgentID).ToString()] = m;
+                }
+
+                OSDMap osddefaults = new OSDMap();
+                osddefaults["default_powers"] = new OSDString(defaultPowers.ToString("X"));
+
+                resp["group_id"] = new OSDUUID(groupID);
+                resp["agent_id"] = new OSDUUID(m_AgentID);
+                resp["member_count"] = new OSDInteger(memberCount);
+                resp["defaults"] = osddefaults;
+                resp["titles"] = osdtitles;
+                resp["members"] = osdmembers;
+
+                fail = false;
+                break;
+            }
+
+            if(fail)
+            {
+                resp["group_id"] = new OSDUUID(groupID);
+                resp["agent_id"] = new OSDUUID(m_AgentID);
+                resp["member_count"] = new OSDInteger(0);
+                resp["defaults"] = new OSDMap();
+                resp["titles"] = new OSDArray();
+                resp["members"] = new OSDMap();
+            }
+
+            response = OSDParser.SerializeLLSDXmlString(resp);
+            return response;
+        }
+
+        public string GetDisplayNames(string request, string path,
+                string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.Gone;
+            httpResponse.ContentType = "text/plain";
+
+            ScenePresence sp = m_Scene.GetScenePresence(m_AgentID);
+            if(sp == null || sp.IsDeleted)
+                return "";
+
+            if(sp.IsInTransit && !sp.IsInLocalTransit)
+            {
+                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.ServiceUnavailable;
+                httpResponse.AddHeader("Retry-After","30");
+                return "";
+            }
+
+            NameValueCollection query = HttpUtility.ParseQueryString(httpRequest.Url.Query);
+            string[] ids = query.GetValues("ids");
+
+            Dictionary<UUID,string> names = m_UserManager.GetUsersNames(ids);
+
+            OSDMap osdReply = new OSDMap();
+            OSDArray agents = new OSDArray();
+
+            osdReply["agents"] = agents;
+            foreach (KeyValuePair<UUID,string> kvp in names)
+            {
+                if (string.IsNullOrEmpty(kvp.Value))
+                    continue;
+                if(kvp.Key == UUID.Zero)
+                    continue;
+
+                string[] parts = kvp.Value.Split(new char[] {' '});
+                OSDMap osdname = new OSDMap();
+
+                // dont tell about unknown users, we can't send them back on Bad either
+                if(parts[0] == "Unknown")
+                     continue;
+/*
+                if(parts[0] == "Unknown")
+                {
+                    osdname["display_name_next_update"] = OSD.FromDate(DateTime.UtcNow.AddHours(1));
+                    osdname["display_name_expires"] = OSD.FromDate(DateTime.UtcNow.AddHours(2));
+                }
+                else
+*/
+                {
+                    osdname["display_name_next_update"] = OSD.FromDate(DateTime.UtcNow.AddDays(8));
+                    osdname["display_name_expires"] = OSD.FromDate(DateTime.UtcNow.AddMonths(1));
+                }
+                osdname["display_name"] = OSD.FromString(kvp.Value);
+                osdname["legacy_first_name"] = parts[0];
+                osdname["legacy_last_name"] = parts[1];
+                osdname["username"] = OSD.FromString(kvp.Value);
+                osdname["id"] = OSD.FromUUID(kvp.Key);
+                osdname["is_display_name_default"] = OSD.FromBoolean(true);
+
+                agents.Add(osdname);
+            }
+
+            // Full content request
+            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.OK;
+            //httpResponse.ContentLength = ??;
+            httpResponse.ContentType = "application/llsd+xml";
+
+            string reply = OSDParser.SerializeLLSDXmlString(osdReply);
+            return reply;
+        }
+    }
+
+    public class AssetUploader
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+
+        public event UpLoadedAsset OnUpLoad;
+        private UpLoadedAsset handlerUpLoad = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID newAssetID;
+        private UUID inventoryItemID;
+        private UUID parentFolder;
+        private IHttpServer httpListener;
+        private bool m_dumpAssetsToFile;
+        private string m_assetName = String.Empty;
+        private string m_assetDes = String.Empty;
+
+        private string m_invType = String.Empty;
+        private string m_assetType = String.Empty;
+        private int m_cost;
+        private string m_error = String.Empty;
+
+        private Timer m_timeoutTimer = new Timer();
+        private UUID m_texturesFolder;
+        private int m_nreqtextures;
+        private int m_nreqmeshs;
+        private int m_nreqinstances;
+        private bool m_IsAtestUpload;
+
+        private int m_nextOwnerMask;
+        private int m_groupMask;
+        private int m_everyoneMask;
+
+
+        public AssetUploader(string assetName, string description, UUID assetID, UUID inventoryItem,
+                                UUID parentFolderID, string invType, string assetType, string path,
+                                IHttpServer httpServer, bool dumpAssetsToFile,
+                                int totalCost, UUID texturesFolder, int nreqtextures, int nreqmeshs, int nreqinstances,
+                                bool IsAtestUpload, int nextOwnerMask, int groupMask, int everyoneMask)
+        {
+            m_assetName = assetName;
+            m_assetDes = description;
+            newAssetID = assetID;
+            inventoryItemID = inventoryItem;
+            uploaderPath = path;
+            httpListener = httpServer;
+            parentFolder = parentFolderID;
+            m_assetType = assetType;
+            m_invType = invType;
+            m_dumpAssetsToFile = dumpAssetsToFile;
+            m_cost = totalCost;
+
+            m_texturesFolder = texturesFolder;
+            m_nreqtextures = nreqtextures;
+            m_nreqmeshs = nreqmeshs;
+            m_nreqinstances = nreqinstances;
+            m_IsAtestUpload = IsAtestUpload;
+
+            m_timeoutTimer.Elapsed += TimedOut;
+            m_timeoutTimer.Interval = 120000;
+            m_timeoutTimer.AutoReset = false;
+            m_timeoutTimer.Start();
+
+            m_nextOwnerMask = nextOwnerMask;
+            m_groupMask = groupMask;
+            m_everyoneMask = everyoneMask;
+        }
+
+        /// <summary>
+        /// Handle raw asset upload data via the capability.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            UUID inv = inventoryItemID;
+            string res = String.Empty;
+            LLSDAssetUploadComplete uploadComplete = new LLSDAssetUploadComplete();
+/*
+            uploadComplete.new_asset = newAssetID.ToString();
+            uploadComplete.new_inventory_item = inv;
+            uploadComplete.state = "complete";
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+*/
+            m_timeoutTimer.Stop();
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+            // TODO: probably make this a better set of extensions here
+            string extension = ".jp2";
+            if (m_invType != "image")
+            {
+                extension = ".dat";
+            }
+
+            if (m_dumpAssetsToFile)
+            {
+                SaveAssetToFile(m_assetName + extension, data);
+            }
+            handlerUpLoad = OnUpLoad;
+            if (handlerUpLoad != null)
+            {
+                handlerUpLoad(m_assetName, m_assetDes, newAssetID, inv, parentFolder, data, m_invType, m_assetType,
+                    m_cost, m_texturesFolder, m_nreqtextures, m_nreqmeshs, m_nreqinstances, m_IsAtestUpload,
+                    ref m_error, ref m_nextOwnerMask, ref m_groupMask, ref m_everyoneMask);
+            }
+
+            uploadComplete.new_next_owner_mask = m_nextOwnerMask;
+            uploadComplete.new_group_mask = m_groupMask;
+            uploadComplete.new_everyone_mask = m_everyoneMask;
+
+            if (m_IsAtestUpload)
+            {
+                LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                resperror.message = "Upload SUCESSEFULL for testing purposes only. Other uses are prohibited. Item will not work after 48 hours or on other regions";
+                resperror.identifier = inv;
+
+                uploadComplete.error = resperror;
+                uploadComplete.state = "Upload4Testing";
+            }
+            else
+            {
+                if (m_error == String.Empty)
+                {
+                    uploadComplete.new_asset = newAssetID.ToString();
+                    uploadComplete.new_inventory_item = inv;
+                    //                if (m_texturesFolder != UUID.Zero)
+                    //                    uploadComplete.new_texture_folder_id = m_texturesFolder;
+                    uploadComplete.state = "complete";
+                }
+                else
+                {
+                    LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                    resperror.message = m_error;
+                    resperror.identifier = inv;
+
+                    uploadComplete.error = resperror;
+                    uploadComplete.state = "failed";
+                }
+            }
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+            return res;
+        }
+
+        private void TimedOut(object sender, ElapsedEventArgs args)
+        {
+            m_log.InfoFormat("[CAPS]: Removing URL and handler for timed out mesh upload");
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+        }
+
+        ///Left this in and commented in case there are unforseen issues
+        //private void SaveAssetToFile(string filename, byte[] data)
+        //{
+        //    FileStream fs = File.Create(filename);
+        //    BinaryWriter bw = new BinaryWriter(fs);
+        //    bw.Write(data);
+        //    bw.Close();
+        //    fs.Close();
+        //}
+
+        private static void SaveAssetToFile(string filename, byte[] data)
+        {
+            string assetPath = "UserAssets";
+            if (!Directory.Exists(assetPath))
+            {
+                Directory.CreateDirectory(assetPath);
+            }
+            FileStream fs = File.Create(Path.Combine(assetPath, Util.safeFileName(filename)));
+            BinaryWriter bw = new BinaryWriter(fs);
+            bw.Write(data);
+            bw.Close();
+            fs.Close();
+        }
+    }
+
+    /// <summary>
+    /// This class is a callback invoked when a client sends asset data to
+    /// an agent inventory notecard update url
+    /// </summary>
+    public class ItemUpdater
+    {
+        public event UpdateItem OnUpLoad;
+
+        private UpdateItem handlerUpdateItem = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID inventoryItemID;
+        private IHttpServer httpListener;
+        private bool m_dumpAssetToFile;
+
+        public ItemUpdater(UUID inventoryItem, string path, IHttpServer httpServer, bool dumpAssetToFile)
+        {
+            m_dumpAssetToFile = dumpAssetToFile;
+
+            inventoryItemID = inventoryItem;
+            uploaderPath = path;
+            httpListener = httpServer;
+        }
+
+        /// <summary>
+        /// Handle raw uploaded asset data.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            UUID inv = inventoryItemID;
+            string res = String.Empty;
+            LLSDAssetUploadComplete uploadComplete = new LLSDAssetUploadComplete();
+            UUID assetID = UUID.Zero;
+            handlerUpdateItem = OnUpLoad;
+            if (handlerUpdateItem != null)
+            {
+                assetID = handlerUpdateItem(inv, data);
+            }
+
+            uploadComplete.new_asset = assetID.ToString();
+            uploadComplete.new_inventory_item = inv;
+            uploadComplete.state = "complete";
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+            if (m_dumpAssetToFile)
+            {
+                SaveAssetToFile("updateditem" + Util.RandomClass.Next(1, 1000) + ".dat", data);
+            }
+
+            return res;
+        }
+
+        ///Left this in and commented in case there are unforseen issues
+        //private void SaveAssetToFile(string filename, byte[] data)
+        //{
+        //    FileStream fs = File.Create(filename);
+        //    BinaryWriter bw = new BinaryWriter(fs);
+        //    bw.Write(data);
+        //    bw.Close();
+        //    fs.Close();
+        //}
+
+        private static void SaveAssetToFile(string filename, byte[] data)
+        {
+            string assetPath = "UserAssets";
+            if (!Directory.Exists(assetPath))
+            {
+                Directory.CreateDirectory(assetPath);
+            }
+            FileStream fs = File.Create(Path.Combine(assetPath, filename));
+            BinaryWriter bw = new BinaryWriter(fs);
+            bw.Write(data);
+            bw.Close();
+            fs.Close();
+        }
+    }
+
+    /// <summary>
+    /// This class is a callback invoked when a client sends asset data to
+    /// a task inventory script update url
+    /// </summary>
+    public class TaskInventoryScriptUpdater
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public event UpdateTaskScript OnUpLoad;
+
+        private UpdateTaskScript handlerUpdateTaskScript = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID inventoryItemID;
+        private UUID primID;
+        private bool isScriptRunning;
+        private IHttpServer httpListener;
+        private bool m_dumpAssetToFile;
+
+        public TaskInventoryScriptUpdater(UUID inventoryItemID, UUID primID, int isScriptRunning,
+                                            string path, IHttpServer httpServer, bool dumpAssetToFile)
+        {
+            m_dumpAssetToFile = dumpAssetToFile;
+
+            this.inventoryItemID = inventoryItemID;
+            this.primID = primID;
+
+            // This comes in over the packet as an integer, but actually appears to be treated as a bool
+            this.isScriptRunning = (0 == isScriptRunning ? false : true);
+
+            uploaderPath = path;
+            httpListener = httpServer;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            try
+            {
+                //                    m_log.InfoFormat("[CAPS]: " +
+                //                                     "TaskInventoryScriptUpdater received data: {0}, path: {1}, param: {2}",
+                //                                     data, path, param));
+
+                string res = String.Empty;
+                LLSDTaskScriptUploadComplete uploadComplete = new LLSDTaskScriptUploadComplete();
+
+                ArrayList errors = new ArrayList();
+                handlerUpdateTaskScript = OnUpLoad;
+                if (handlerUpdateTaskScript != null)
+                {
+                    handlerUpdateTaskScript(inventoryItemID, primID, isScriptRunning, data, ref errors);
+                }
+
+                uploadComplete.new_asset = inventoryItemID;
+                uploadComplete.compiled = errors.Count > 0 ? false : true;
+                uploadComplete.state = "complete";
+                uploadComplete.errors = new OpenSim.Framework.Capabilities.OSDArray();
+                uploadComplete.errors.Array = errors;
+
+                res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+                httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+                if (m_dumpAssetToFile)
+                {
+                    SaveAssetToFile("updatedtaskscript" + Util.RandomClass.Next(1, 1000) + ".dat", data);
+                }
+
+                //                    m_log.InfoFormat("[CAPS]: TaskInventoryScriptUpdater.uploaderCaps res: {0}", res);
+
+                return res;
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+
+            // XXX Maybe this should be some meaningful error packet
+            return null;
+        }
+
+        ///Left this in and commented in case there are unforseen issues
+        //private void SaveAssetToFile(string filename, byte[] data)
+        //{
+        //    FileStream fs = File.Create(filename);
+        //    BinaryWriter bw = new BinaryWriter(fs);
+        //    bw.Write(data);
+        //    bw.Close();
+        //    fs.Close();
+        //}
+        private static void SaveAssetToFile(string filename, byte[] data)
+        {
+            string assetPath = "UserAssets";
+            if (!Directory.Exists(assetPath))
+            {
+                Directory.CreateDirectory(assetPath);
+            }
+            FileStream fs = File.Create(Path.Combine(assetPath, filename));
+            BinaryWriter bw = new BinaryWriter(fs);
+            bw.Write(data);
+            bw.Close();
+            fs.Close();
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs
new file mode 100644
index 0000000..683c3d5
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs
@@ -0,0 +1,91 @@
+/*
+ * 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 Mono.Addins;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+[assembly: Addin("LindenCaps", OpenSim.VersionInfo.VersionNumber)]
+[assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
+namespace OpenSim.Region.ClientStack.Linden
+{
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "BunchOfCapsModule")]
+    public class BunchOfCapsModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_Scene;
+
+        #region INonSharedRegionModule
+
+        public string Name { get { return "BunchOfCapsModule"; } }
+
+        public Type ReplaceableInterface { get { return null; } }
+
+        public void Initialise(IConfigSource source)
+        {
+        }
+
+        public void Close() { }
+
+        public void AddRegion(Scene scene)
+        {
+            m_Scene = scene;
+            m_Scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public void PostInitialise() { }
+        #endregion
+
+        private void OnRegisterCaps(UUID agentID, Caps caps)
+        {
+            new BunchOfCaps(m_Scene, agentID, caps);
+        }
+
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/MeshCost.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/MeshCost.cs
new file mode 100644
index 0000000..eb1ab45
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/MeshCost.cs
@@ -0,0 +1,746 @@
+/*
+ * 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 OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Capabilities;
+
+using ComponentAce.Compression.Libs.zlib;
+
+using OSDArray = OpenMetaverse.StructuredData.OSDArray;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+
+using Nini.Config;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public struct ModelPrimLimits
+    {
+
+    }
+
+    public class ModelCost
+    {
+
+        // upload fee defaults
+        // fees are normalized to 1.0
+        // this parameters scale them to basic cost ( so 1.0 translates to 10 )
+
+        public float ModelMeshCostFactor = 0.0f; // scale total cost relative to basic (excluding textures)
+        public float ModelTextureCostFactor = 1.0f; // scale textures fee to basic.
+        public float ModelMinCostFactor = 0.0f; // 0.5f; // minimum total model free excluding textures
+
+        // itens costs in normalized values
+        // ie will be multiplied by basicCost and factors above
+        public float primCreationCost = 0.002f;  // extra cost for each prim creation overhead
+        // weigthed size to normalized cost
+        public float bytecost = 1e-5f;
+
+        // mesh upload fees based on compressed data sizes
+        // several data sections are counted more that once
+        // to promote user optimization
+        // following parameters control how many extra times they are added
+        // to global size.
+        // LOD meshs
+        const float medSizeWth = 1f; // 2x
+        const float lowSizeWth = 1.5f; // 2.5x
+        const float lowestSizeWth = 2f; // 3x
+        // favor potencially physical optimized meshs versus automatic decomposition
+        const float physMeshSizeWth = 6f; // counts  7x
+        const float physHullSizeWth = 8f; // counts  9x
+
+        // stream cost area factors
+        // more or less like SL
+        const float highLodFactor = 17.36f;
+        const float midLodFactor = 277.78f;
+        const float lowLodFactor = 1111.11f;
+
+        // physics cost is below, identical to SL, assuming shape type convex
+        // server cost is below identical to SL assuming non scripted non physical object
+
+        // internal
+        const int bytesPerCoord = 6; // 3 coords, 2 bytes per each
+
+        // control prims dimensions
+        public float PrimScaleMin = 0.001f;
+        public float NonPhysicalPrimScaleMax = 256f;
+        public float PhysicalPrimScaleMax = 10f;
+        public int ObjectLinkedPartsMax = 512;
+
+
+        public ModelCost(Scene scene)
+        {
+            PrimScaleMin = scene.m_minNonphys;
+            NonPhysicalPrimScaleMax = scene.m_maxNonphys;
+            PhysicalPrimScaleMax = scene.m_maxPhys;
+            ObjectLinkedPartsMax = scene.m_linksetCapacity;
+        }
+
+        public void Econfig(IConfig EconomyConfig)
+        {
+            ModelMeshCostFactor = EconomyConfig.GetFloat("MeshModelUploadCostFactor", ModelMeshCostFactor);
+            ModelTextureCostFactor = EconomyConfig.GetFloat("MeshModelUploadTextureCostFactor", ModelTextureCostFactor);
+            ModelMinCostFactor = EconomyConfig.GetFloat("MeshModelMinCostFactor", ModelMinCostFactor);
+                    // next 2 are normalized so final cost is afected by modelUploadFactor above and normal cost
+            primCreationCost = EconomyConfig.GetFloat("ModelPrimCreationCost", primCreationCost);
+            bytecost = EconomyConfig.GetFloat("ModelMeshByteCost", bytecost);
+        }
+
+        // storage for a single mesh asset cost parameters
+        private class ameshCostParam
+        {
+            // LOD sizes for size dependent streaming cost
+            public int highLODSize;
+            public int medLODSize;
+            public int lowLODSize;
+            public int lowestLODSize;
+            // normalized fee based on compressed data sizes
+            public float costFee;
+            // physics cost
+            public float physicsCost;
+        }
+
+        // calculates a mesh model costs
+        // returns false on error, with a reason on parameter error
+        // resources input LLSD request
+        // basicCost input region assets upload cost
+        // totalcost returns model total upload fee
+        // meshcostdata returns detailed costs for viewer
+        // avatarSkeleton if mesh includes a avatar skeleton
+        // useAvatarCollider if we should use physics mesh for avatar
+        public bool MeshModelCost(LLSDAssetResource resources, int basicCost, out int totalcost,
+            LLSDAssetUploadResponseData meshcostdata, out string error, ref string warning)
+        {
+            totalcost = 0;
+            error = string.Empty;
+
+            bool avatarSkeleton = false;
+
+            if (resources == null ||
+                resources.instance_list == null ||
+                resources.instance_list.Array.Count == 0)
+            {
+                error = "missing model information.";
+                return false;
+            }
+
+            int numberInstances = resources.instance_list.Array.Count;
+
+            if (ObjectLinkedPartsMax != 0 && numberInstances > ObjectLinkedPartsMax)
+            {
+                error = "Model would have more than " + ObjectLinkedPartsMax.ToString() + " linked prims";
+                return false;
+            }
+
+            meshcostdata.model_streaming_cost = 0.0;
+            meshcostdata.simulation_cost = 0.0;
+            meshcostdata.physics_cost = 0.0;
+            meshcostdata.resource_cost = 0.0;
+
+            meshcostdata.upload_price_breakdown.mesh_instance = 0;
+            meshcostdata.upload_price_breakdown.mesh_physics = 0;
+            meshcostdata.upload_price_breakdown.mesh_streaming = 0;
+            meshcostdata.upload_price_breakdown.model = 0;
+
+            int itmp;
+
+            // textures cost
+            if (resources.texture_list != null && resources.texture_list.Array.Count > 0)
+            {
+                float textures_cost = (float)(resources.texture_list.Array.Count * basicCost);
+                textures_cost *= ModelTextureCostFactor;
+
+                itmp = (int)(textures_cost + 0.5f); // round
+                meshcostdata.upload_price_breakdown.texture = itmp;
+                totalcost += itmp;
+            }
+
+            // meshs assets cost
+            float meshsfee = 0;
+            int numberMeshs = 0;
+            bool haveMeshs = false;
+
+            bool curskeleton;
+            bool curAvatarPhys;
+
+            List<ameshCostParam> meshsCosts = new List<ameshCostParam>();
+
+            if (resources.mesh_list != null && resources.mesh_list.Array.Count > 0)
+            {
+                numberMeshs = resources.mesh_list.Array.Count;
+
+                for (int i = 0; i < numberMeshs; i++)
+                {
+                    ameshCostParam curCost = new ameshCostParam();
+                    byte[] data = (byte[])resources.mesh_list.Array[i];
+
+                    if (!MeshCost(data, curCost,out curskeleton, out curAvatarPhys, out error))
+                    {
+                        return false;
+                    }
+
+                    if (curskeleton)
+                    {
+                        if (avatarSkeleton)
+                        {
+                            error = "model can only contain a avatar skeleton";
+                            return false;
+                        }
+                        avatarSkeleton = true;
+                    }
+                    meshsCosts.Add(curCost);
+                    meshsfee += curCost.costFee;
+                }
+                haveMeshs = true;
+            }
+
+            // instances (prims) cost
+
+
+            int mesh;
+            int skipedSmall = 0;
+            for (int i = 0; i < numberInstances; i++)
+            {
+                Hashtable inst = (Hashtable)resources.instance_list.Array[i];
+
+                ArrayList ascale = (ArrayList)inst["scale"];
+                Vector3 scale;
+                double tmp;
+                tmp = (double)ascale[0];
+                scale.X = (float)tmp;
+                tmp = (double)ascale[1];
+                scale.Y = (float)tmp;
+                tmp = (double)ascale[2];
+                scale.Z = (float)tmp;
+
+                if (scale.X < PrimScaleMin || scale.Y < PrimScaleMin || scale.Z < PrimScaleMin)
+                {
+                    skipedSmall++;
+                    continue;
+                }
+
+                if (scale.X > NonPhysicalPrimScaleMax || scale.Y > NonPhysicalPrimScaleMax || scale.Z > NonPhysicalPrimScaleMax)
+                {
+                    error = "Model contains parts with sides larger than " + NonPhysicalPrimScaleMax.ToString() + "m. Please ajust scale";
+                    return false;
+                }
+
+                if (haveMeshs && inst.ContainsKey("mesh"))
+                {
+                    mesh = (int)inst["mesh"];
+
+                    if (mesh >= numberMeshs)
+                    {
+                        error = "Incoerent model information.";
+                        return false;
+                    }
+
+                    // streamming cost
+
+                    float sqdiam = scale.LengthSquared();
+
+                    ameshCostParam curCost = meshsCosts[mesh];
+                    float mesh_streaming = streamingCost(curCost, sqdiam);
+
+                    meshcostdata.model_streaming_cost += mesh_streaming;
+                    meshcostdata.physics_cost += curCost.physicsCost;
+                }
+                else // instance as no mesh ??
+                {
+                    // to do later if needed
+                    meshcostdata.model_streaming_cost += 0.5f;
+                    meshcostdata.physics_cost += 1.0f;
+                }
+
+                // assume unscripted and static prim server cost
+                meshcostdata.simulation_cost += 0.5f;
+                // charge for prims creation
+                meshsfee += primCreationCost;
+            }
+
+            if (skipedSmall > 0)
+            {
+                if (skipedSmall > numberInstances / 2)
+                {
+                    error = "Model contains too many prims smaller than " + PrimScaleMin.ToString() +
+                        "m minimum allowed size. Please check scalling";
+                    return false;
+                }
+                else
+                    warning += skipedSmall.ToString() + " of the requested " +numberInstances.ToString() +
+                        " model prims will not upload because they are smaller than " + PrimScaleMin.ToString() +
+                        "m minimum allowed size. Please check scalling ";
+            }
+
+            if (meshcostdata.physics_cost <= meshcostdata.model_streaming_cost)
+                meshcostdata.resource_cost = meshcostdata.model_streaming_cost;
+            else
+                meshcostdata.resource_cost = meshcostdata.physics_cost;
+
+            if (meshcostdata.resource_cost < meshcostdata.simulation_cost)
+                meshcostdata.resource_cost = meshcostdata.simulation_cost;
+
+            // scale cost
+            // at this point a cost of 1.0 whould mean basic cost
+            meshsfee *= ModelMeshCostFactor;
+
+            if (meshsfee < ModelMinCostFactor)
+                meshsfee = ModelMinCostFactor;
+
+            // actually scale it to basic cost
+            meshsfee *= (float)basicCost;
+
+            meshsfee += 0.5f; // rounding
+
+            totalcost += (int)meshsfee;
+
+            // breakdown prices
+            // don't seem to be in use so removed code for now
+
+            return true;
+        }
+
+        // single mesh asset cost
+        private bool MeshCost(byte[] data, ameshCostParam cost,out bool skeleton, out bool avatarPhys, out string error)
+        {
+            cost.highLODSize = 0;
+            cost.medLODSize = 0;
+            cost.lowLODSize = 0;
+            cost.lowestLODSize = 0;
+            cost.physicsCost = 0.0f;
+            cost.costFee = 0.0f;
+
+            error = string.Empty;
+
+            skeleton = false;
+            avatarPhys = false;
+
+            if (data == null || data.Length == 0)
+            {
+                error = "Missing model information.";
+                return false;
+            }
+
+            OSD meshOsd = null;
+            int start = 0;
+
+            error = "Invalid model data";
+
+            using (MemoryStream ms = new MemoryStream(data))
+            {
+                try
+                {
+                    OSD osd = OSDParser.DeserializeLLSDBinary(ms);
+                    if (osd is OSDMap)
+                        meshOsd = (OSDMap)osd;
+                    else
+                        return false;
+                }
+                catch
+                {
+                    return false;
+                }
+                start = (int)ms.Position;
+            }
+
+            OSDMap map = (OSDMap)meshOsd;
+            OSDMap tmpmap;
+
+            int highlod_size = 0;
+            int medlod_size = 0;
+            int lowlod_size = 0;
+            int lowestlod_size = 0;
+            int skin_size = 0;
+
+            int hulls_size = 0;
+            int phys_nhulls;
+            int phys_hullsvertices = 0;
+
+            int physmesh_size = 0;
+            int phys_ntriangles = 0;
+
+            int submesh_offset = -1;
+
+            if (map.ContainsKey("skeleton"))
+            {
+                tmpmap = (OSDMap)map["skeleton"];
+                if (tmpmap.ContainsKey("offset") && tmpmap.ContainsKey("size"))
+                {
+                    int sksize = tmpmap["size"].AsInteger();
+                    if(sksize > 0)
+                        skeleton = true;
+                }
+            }
+
+            if (map.ContainsKey("physics_convex"))
+            {
+                tmpmap = (OSDMap)map["physics_convex"];
+                if (tmpmap.ContainsKey("offset"))
+                    submesh_offset = tmpmap["offset"].AsInteger() + start;
+                if (tmpmap.ContainsKey("size"))
+                    hulls_size = tmpmap["size"].AsInteger();
+            }
+
+            if (submesh_offset < 0 || hulls_size == 0)
+            {
+                error = "Missing physics_convex block";
+                return false;
+            }
+
+            if (!hulls(data, submesh_offset, hulls_size, out phys_hullsvertices, out phys_nhulls))
+            {
+                error = "Bad physics_convex block";
+                return false;
+            }
+
+            submesh_offset = -1;
+
+            // only look for LOD meshs sizes
+
+            if (map.ContainsKey("high_lod"))
+            {
+                tmpmap = (OSDMap)map["high_lod"];
+                // see at least if there is a offset for this one
+                if (tmpmap.ContainsKey("offset"))
+                    submesh_offset = tmpmap["offset"].AsInteger() + start;
+                if (tmpmap.ContainsKey("size"))
+                    highlod_size = tmpmap["size"].AsInteger();
+            }
+
+            if (submesh_offset < 0 || highlod_size <= 0)
+            {
+                error = "Missing high_lod block";
+                return false;
+            }
+
+            bool haveprev = true;
+
+            if (map.ContainsKey("medium_lod"))
+            {
+                tmpmap = (OSDMap)map["medium_lod"];
+                if (tmpmap.ContainsKey("size"))
+                    medlod_size = tmpmap["size"].AsInteger();
+                else
+                    haveprev = false;
+            }
+
+            if (haveprev && map.ContainsKey("low_lod"))
+            {
+                tmpmap = (OSDMap)map["low_lod"];
+                if (tmpmap.ContainsKey("size"))
+                    lowlod_size = tmpmap["size"].AsInteger();
+                else
+                    haveprev = false;
+            }
+
+            if (haveprev && map.ContainsKey("lowest_lod"))
+            {
+                tmpmap = (OSDMap)map["lowest_lod"];
+                if (tmpmap.ContainsKey("size"))
+                    lowestlod_size = tmpmap["size"].AsInteger();
+            }
+
+            if (map.ContainsKey("skin"))
+            {
+                tmpmap = (OSDMap)map["skin"];
+                if (tmpmap.ContainsKey("size"))
+                    skin_size = tmpmap["size"].AsInteger();
+            }
+
+            cost.highLODSize = highlod_size;
+            cost.medLODSize = medlod_size;
+            cost.lowLODSize = lowlod_size;
+            cost.lowestLODSize = lowestlod_size;
+
+            submesh_offset = -1;
+
+            tmpmap = null;
+            if(map.ContainsKey("physics_mesh"))
+                tmpmap = (OSDMap)map["physics_mesh"];
+            else if (map.ContainsKey("physics_shape")) // old naming
+                tmpmap = (OSDMap)map["physics_shape"];
+
+            if(tmpmap != null)
+            {
+                if (tmpmap.ContainsKey("offset"))
+                    submesh_offset = tmpmap["offset"].AsInteger() + start;
+                if (tmpmap.ContainsKey("size"))
+                    physmesh_size = tmpmap["size"].AsInteger();
+
+                if (submesh_offset >= 0 || physmesh_size > 0)
+                {
+
+                    if (!submesh(data, submesh_offset, physmesh_size, out phys_ntriangles))
+                    {
+                        error = "Model data parsing error";
+                        return false;
+                    }
+                }
+            }
+
+            // upload is done in convex shape type so only one hull
+            phys_hullsvertices++;
+            cost.physicsCost = 0.04f * phys_hullsvertices;
+
+            float sfee;
+
+            sfee = data.Length; // start with total compressed data size
+
+            // penalize lod meshs that should be more builder optimized
+            sfee += medSizeWth * medlod_size;
+            sfee += lowSizeWth * lowlod_size;
+            sfee += lowestSizeWth * lowlod_size;
+
+            // physics
+            // favor potencial optimized meshs versus automatic decomposition
+            if (physmesh_size != 0)
+                sfee += physMeshSizeWth * (physmesh_size + hulls_size / 4); // reduce cost of mandatory convex hull
+            else
+                sfee += physHullSizeWth * hulls_size;
+
+            // bytes to money
+            sfee *= bytecost;
+
+            cost.costFee = sfee;
+            return true;
+        }
+
+        // parses a LOD or physics mesh component
+        private bool submesh(byte[] data, int offset, int size, out int ntriangles)
+        {
+            ntriangles = 0;
+
+            OSD decodedMeshOsd = new OSD();
+            byte[] meshBytes = new byte[size];
+            System.Buffer.BlockCopy(data, offset, meshBytes, 0, size);
+            try
+            {
+                using (MemoryStream inMs = new MemoryStream(meshBytes))
+                {
+                    using (MemoryStream outMs = new MemoryStream())
+                    {
+                        using (ZOutputStream zOut = new ZOutputStream(outMs))
+                        {
+                            byte[] readBuffer = new byte[4096];
+                            int readLen = 0;
+                            while ((readLen = inMs.Read(readBuffer, 0, readBuffer.Length)) > 0)
+                            {
+                                zOut.Write(readBuffer, 0, readLen);
+                            }
+                            zOut.Flush();
+                            outMs.Seek(0, SeekOrigin.Begin);
+
+                            byte[] decompressedBuf = outMs.GetBuffer();
+                            decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
+                        }
+                    }
+                }
+            }
+            catch
+            {
+                return false;
+            }
+
+            OSDArray decodedMeshOsdArray = null;
+
+            byte[] dummy;
+
+            decodedMeshOsdArray = (OSDArray)decodedMeshOsd;
+            foreach (OSD subMeshOsd in decodedMeshOsdArray)
+            {
+                if (subMeshOsd is OSDMap)
+                {
+                    OSDMap subtmpmap = (OSDMap)subMeshOsd;
+                    if (subtmpmap.ContainsKey("NoGeometry") && ((OSDBoolean)subtmpmap["NoGeometry"]))
+                        continue;
+
+                    if (!subtmpmap.ContainsKey("Position"))
+                        return false;
+
+                    if (subtmpmap.ContainsKey("TriangleList"))
+                    {
+                        dummy = subtmpmap["TriangleList"].AsBinary();
+                        ntriangles += dummy.Length / bytesPerCoord;
+                    }
+                    else
+                        return false;
+                }
+            }
+
+            return true;
+        }
+
+        // parses convex hulls component
+        private bool hulls(byte[] data, int offset, int size, out int nvertices, out int nhulls)
+        {
+            nvertices = 0;
+            nhulls = 1;
+
+            OSD decodedMeshOsd = new OSD();
+            byte[] meshBytes = new byte[size];
+            System.Buffer.BlockCopy(data, offset, meshBytes, 0, size);
+            try
+            {
+                using (MemoryStream inMs = new MemoryStream(meshBytes))
+                {
+                    using (MemoryStream outMs = new MemoryStream())
+                    {
+                        using (ZOutputStream zOut = new ZOutputStream(outMs))
+                        {
+                            byte[] readBuffer = new byte[4096];
+                            int readLen = 0;
+                            while ((readLen = inMs.Read(readBuffer, 0, readBuffer.Length)) > 0)
+                            {
+                                zOut.Write(readBuffer, 0, readLen);
+                            }
+                            zOut.Flush();
+                            outMs.Seek(0, SeekOrigin.Begin);
+
+                            byte[] decompressedBuf = outMs.GetBuffer();
+                            decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
+                        }
+                    }
+                }
+            }
+            catch
+            {
+                return false;
+            }
+
+            OSDMap cmap = (OSDMap)decodedMeshOsd;
+            if (cmap == null)
+                return false;
+
+            byte[] dummy;
+
+            // must have one of this
+            if (cmap.ContainsKey("BoundingVerts"))
+            {
+                dummy = cmap["BoundingVerts"].AsBinary();
+                nvertices = dummy.Length / bytesPerCoord;
+            }
+            else
+                return false;
+
+/* upload is done with convex shape type
+            if (cmap.ContainsKey("HullList"))
+            {
+                dummy = cmap["HullList"].AsBinary();
+                nhulls += dummy.Length;
+            }
+
+
+            if (cmap.ContainsKey("Positions"))
+            {
+                dummy = cmap["Positions"].AsBinary();
+                nvertices = dummy.Length / bytesPerCoord;
+            }
+ */
+
+            return true;
+        }
+
+        // returns streaming cost from on mesh LODs sizes in curCost and square of prim size length
+        private float streamingCost(ameshCostParam curCost, float sqdiam)
+        {
+            // compute efective areas
+            float ma = 262144f;
+
+            float mh = sqdiam * highLodFactor;
+            if (mh > ma)
+                mh = ma;
+            float mm = sqdiam * midLodFactor;
+            if (mm > ma)
+                mm = ma;
+
+            float ml = sqdiam * lowLodFactor;
+            if (ml > ma)
+                ml = ma;
+
+            float mlst = ma;
+
+            mlst -= ml;
+            ml -= mm;
+            mm -= mh;
+
+            if (mlst < 1.0f)
+                mlst = 1.0f;
+            if (ml < 1.0f)
+                ml = 1.0f;
+            if (mm < 1.0f)
+                mm = 1.0f;
+            if (mh < 1.0f)
+                mh = 1.0f;
+
+            ma = mlst + ml + mm + mh;
+
+            // get LODs compressed sizes
+            // giving 384 bytes bonus
+            int lst = curCost.lowestLODSize - 384;
+            int l = curCost.lowLODSize - 384;
+            int m = curCost.medLODSize - 384;
+            int h = curCost.highLODSize - 384;
+
+            // use previus higher LOD size on missing ones
+            if (m <= 0)
+                m = h;
+            if (l <= 0)
+                l = m;
+            if (lst <= 0)
+                lst = l;
+
+            // force minumum sizes
+            if (lst < 16)
+                lst = 16;
+            if (l < 16)
+                l = 16;
+            if (m < 16)
+                m = 16;
+            if (h < 16)
+                h = 16;
+
+            // compute cost weighted by relative effective areas
+            float cost = (float)lst * mlst + (float)l * ml + (float)m * mm + (float)h * mh;
+            cost /= ma;
+
+            cost *= 0.004f; // overall tunning parameter
+
+            return cost;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
new file mode 100644
index 0000000..7c9a1c4
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
@@ -0,0 +1,623 @@
+/*
+ * 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.Net;
+using System.Reflection;
+using System.Threading;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.Messages.Linden;
+using OpenMetaverse.Packets;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using BlockingLLSDQueue = OpenSim.Framework.BlockingQueue<OpenMetaverse.StructuredData.OSD>;
+using Caps=OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public struct QueueItem
+    {
+        public int id;
+        public OSDMap body;
+    }
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "EventQueueGetModule")]
+    public class EventQueueGetModule : IEventQueue, INonSharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[EVENT QUEUE GET MODULE]";
+
+        /// <value>
+        /// Debug level.
+        /// </value>
+        public int DebugLevel { get; set; }
+
+        // Viewer post requests timeout in 60 secs
+        // https://bitbucket.org/lindenlab/viewer-release/src/421c20423df93d650cc305dc115922bb30040999/indra/llmessage/llhttpclient.cpp?at=default#cl-44
+        //
+        private const int VIEWER_TIMEOUT = 60 * 1000;
+        // Just to be safe, we work on a 10 sec shorter cycle
+        private const int SERVER_EQ_TIME_NO_EVENTS = VIEWER_TIMEOUT - (10 * 1000);
+
+        protected Scene m_scene;
+
+        private Dictionary<UUID, int> m_ids = new Dictionary<UUID, int>();
+
+        private Dictionary<UUID, Queue<OSD>> queues = new Dictionary<UUID, Queue<OSD>>();
+        private Dictionary<UUID, UUID> m_AvatarQueueUUIDMapping = new Dictionary<UUID, UUID>();
+
+        #region INonSharedRegionModule methods
+        public virtual void Initialise(IConfigSource config)
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            m_scene = scene;
+            scene.RegisterModuleInterface<IEventQueue>(this);
+
+            scene.EventManager.OnClientClosed += ClientClosed;
+            scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+
+            MainConsole.Instance.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug eq",
+                "debug eq [0|1|2]",
+                "Turn on event queue debugging\n"
+                    + "  <= 0 - turns off all event queue logging\n"
+                    + "  >= 1 - turns on event queue setup and outgoing event logging\n"
+                    + "  >= 2 - turns on poll notification",
+                HandleDebugEq);
+
+            MainConsole.Instance.Commands.AddCommand(
+                "Debug",
+                false,
+                "show eq",
+                "show eq",
+                "Show contents of event queues for logged in avatars.  Used for debugging.",
+                HandleShowEq);
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (m_scene != scene)
+                return;
+
+            scene.EventManager.OnClientClosed -= ClientClosed;
+            scene.EventManager.OnRegisterCaps -= OnRegisterCaps;
+
+            scene.UnregisterModuleInterface<IEventQueue>(this);
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public virtual void Close()
+        {
+        }
+
+        public virtual string Name
+        {
+            get { return "EventQueueGetModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        protected void HandleDebugEq(string module, string[] args)
+        {
+            int debugLevel;
+
+            if (!(args.Length == 3 && int.TryParse(args[2], out debugLevel)))
+            {
+                MainConsole.Instance.OutputFormat("Usage: debug eq [0|1|2]");
+            }
+            else
+            {
+                DebugLevel = debugLevel;
+                MainConsole.Instance.OutputFormat(
+                    "Set event queue debug level to {0} in {1}", DebugLevel, m_scene.RegionInfo.RegionName);
+            }
+        }
+
+        protected void HandleShowEq(string module, string[] args)
+        {
+            MainConsole.Instance.OutputFormat("For scene {0}", m_scene.Name);
+
+            lock (queues)
+            {
+                foreach (KeyValuePair<UUID, Queue<OSD>> kvp in queues)
+                {
+                    MainConsole.Instance.OutputFormat(
+                        "For agent {0} there are {1} messages queued for send.",
+                        kvp.Key, kvp.Value.Count);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Always returns a valid queue
+        /// </summary>
+        /// <param name="agentId"></param>
+        /// <returns></returns>
+        private Queue<OSD> TryGetQueue(UUID agentId)
+        {
+            lock (queues)
+            {
+                if (!queues.ContainsKey(agentId))
+                {
+                    if (DebugLevel > 0)
+                        m_log.DebugFormat(
+                            "[EVENTQUEUE]: Adding new queue for agent {0} in region {1}",
+                            agentId, m_scene.RegionInfo.RegionName);
+
+                    queues[agentId] = new Queue<OSD>();
+                }
+
+                return queues[agentId];
+            }
+        }
+
+        /// <summary>
+
+        /// May return a null queue
+        /// </summary>
+        /// <param name="agentId"></param>
+        /// <returns></returns>
+        private Queue<OSD> GetQueue(UUID agentId)
+        {
+            lock (queues)
+            {
+                if (queues.ContainsKey(agentId))
+                {
+                    return queues[agentId];
+                }
+                else
+                    return null;
+            }
+        }
+
+        #region IEventQueue Members
+
+        public bool Enqueue(OSD ev, UUID avatarID)
+        {
+            //m_log.DebugFormat("[EVENTQUEUE]: Enqueuing event for {0} in region {1}", avatarID, m_scene.RegionInfo.RegionName);
+            try
+            {
+                Queue<OSD> queue = GetQueue(avatarID);
+                if (queue != null)
+                {
+                    lock (queue)
+                        queue.Enqueue(ev);
+                }
+                else
+                {
+                        OSDMap evMap = (OSDMap)ev;
+                        m_log.WarnFormat(
+                            "[EVENTQUEUE]: (Enqueue) No queue found for agent {0} when placing message {1} in region {2}",
+                            avatarID, evMap["message"], m_scene.Name);
+                }
+            }
+            catch (NullReferenceException e)
+            {
+                m_log.Error("[EVENTQUEUE] Caught exception: " + e);
+                return false;
+            }
+
+            return true;
+        }
+
+        #endregion
+
+        private void ClientClosed(UUID agentID, Scene scene)
+        {
+            //m_log.DebugFormat("[EVENTQUEUE]: Closed client {0} in region {1}", agentID, m_scene.RegionInfo.RegionName);
+
+            lock (queues)
+                queues.Remove(agentID);
+
+            lock (m_AvatarQueueUUIDMapping)
+                m_AvatarQueueUUIDMapping.Remove(agentID);
+
+            lock (m_ids)
+            {
+                if (!m_ids.ContainsKey(agentID))
+                    m_ids.Remove(agentID);
+            }
+
+            // m_log.DebugFormat("[EVENTQUEUE]: Deleted queues for {0} in region {1}", agentID, m_scene.RegionInfo.RegionName);
+
+        }
+
+        /// <summary>
+        /// Generate an Event Queue Get handler path for the given eqg uuid.
+        /// </summary>
+        /// <param name='eqgUuid'></param>
+        private string GenerateEqgCapPath(UUID eqgUuid)
+        {
+            return string.Format("/CAPS/EQG/{0}/", eqgUuid);
+        }
+
+        public void OnRegisterCaps(UUID agentID, Caps caps)
+        {
+            // Register an event queue for the client
+
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[EVENTQUEUE]: OnRegisterCaps: agentID {0} caps {1} region {2}",
+                    agentID, caps, m_scene.RegionInfo.RegionName);
+
+            UUID eventQueueGetUUID;
+            Queue<OSD> queue;
+            Random rnd = new Random(Environment.TickCount);
+            int nrnd = rnd.Next(30000000);
+            if (nrnd < 0)
+                nrnd = -nrnd;
+
+            lock (queues)
+            {
+                if (queues.ContainsKey(agentID))
+                    queue = queues[agentID];
+                else
+                    queue = null;
+
+                if (queue == null)
+                {
+                    queue = new Queue<OSD>();
+                    queues[agentID] = queue;
+
+                    // push markers to handle old responses still waiting
+                    // this will cost at most viewer getting two forced noevents
+                    // even being a new queue better be safe
+                    queue.Enqueue(null);
+                    queue.Enqueue(null); // one should be enough
+
+                    lock (m_AvatarQueueUUIDMapping)
+                    {
+                        eventQueueGetUUID = UUID.Random();
+                        if (m_AvatarQueueUUIDMapping.ContainsKey(agentID))
+                        {
+                            // oops this should not happen ?
+                            m_log.DebugFormat("[EVENTQUEUE]: Found Existing UUID without a queue");
+                            eventQueueGetUUID = m_AvatarQueueUUIDMapping[agentID];
+                        }
+                        m_AvatarQueueUUIDMapping.Add(agentID, eventQueueGetUUID);
+                    }
+                    lock (m_ids)
+                    {
+                        if (!m_ids.ContainsKey(agentID))
+                            m_ids.Add(agentID, nrnd);
+                        else
+                            m_ids[agentID] = nrnd;
+                    }
+                }
+                else
+                {
+                    // push markers to handle old responses still waiting
+                    // this will cost at most viewer getting two forced noevents
+                    // even being a new queue better be safe
+                    queue.Enqueue(null);
+                    queue.Enqueue(null); // one should be enough
+
+                    // reuse or not to reuse TODO FIX
+                    lock (m_AvatarQueueUUIDMapping)
+                    {
+                        // Reuse open queues.  The client does!
+                        // Its reuse caps path not queues those are been reused already
+                        if (m_AvatarQueueUUIDMapping.ContainsKey(agentID))
+                        {
+                            m_log.DebugFormat("[EVENTQUEUE]: Found Existing UUID!");
+                            eventQueueGetUUID = m_AvatarQueueUUIDMapping[agentID];
+                        }
+                        else
+                        {
+                            eventQueueGetUUID = UUID.Random();
+                            m_AvatarQueueUUIDMapping.Add(agentID, eventQueueGetUUID);
+                            m_log.DebugFormat("[EVENTQUEUE]: Using random UUID!");
+                        }
+                    }
+                    lock (m_ids)
+                    {
+                        // change to negative numbers so they are changed at end of sending first marker
+                        // old data on a queue may be sent on a response for a new caps
+                        // but at least will be sent with coerent IDs
+                        if (!m_ids.ContainsKey(agentID))
+                            m_ids.Add(agentID, -nrnd); // should not happen
+                        else
+                            m_ids[agentID] = -m_ids[agentID];
+                    }
+                }
+            }
+
+            caps.RegisterPollHandler(
+                "EventQueueGet",
+                new PollServiceEventArgs(null, GenerateEqgCapPath(eventQueueGetUUID), HasEvents, GetEvents, NoEvents, agentID, SERVER_EQ_TIME_NO_EVENTS));
+        }
+
+        public bool HasEvents(UUID requestID, UUID agentID)
+        {
+            Queue<OSD> queue = GetQueue(agentID);
+            if (queue != null)
+                lock (queue)
+                {
+                    //m_log.WarnFormat("POLLED FOR EVENTS BY {0} in {1} -- {2}", agentID, m_scene.RegionInfo.RegionName, queue.Count);
+                    return queue.Count > 0;
+                }
+
+            //m_log.WarnFormat("POLLED FOR EVENTS BY {0} unknown agent", agentID);
+            return true;
+        }
+
+        /// <summary>
+        /// Logs a debug line for an outbound event queue message if appropriate.
+        /// </summary>
+        /// <param name='element'>Element containing message</param>
+        private void LogOutboundDebugMessage(OSD element, UUID agentId)
+        {
+            if (element is OSDMap)
+            {
+                OSDMap ev = (OSDMap)element;
+                m_log.DebugFormat(
+                    "Eq OUT {0,-30} to {1,-20} {2,-20}",
+                    ev["message"], m_scene.GetScenePresence(agentId).Name, m_scene.Name);
+            }
+        }
+        public void Drop(UUID requestID, UUID pAgentId)
+        {
+            // do nothing for now, hope client close will do it
+        }
+
+        public Hashtable GetEvents(UUID requestID, UUID pAgentId)
+        {
+            if (DebugLevel >= 2)
+                m_log.WarnFormat("POLLED FOR EQ MESSAGES BY {0} in {1}", pAgentId, m_scene.Name);
+
+            Queue<OSD> queue = GetQueue(pAgentId);
+            if (queue == null)
+            {
+                return NoEvents(requestID, pAgentId);
+            }
+
+            OSD element = null;;
+            OSDArray array = new OSDArray();
+            int thisID = 0;
+            bool negativeID = false;
+
+            lock (queue)
+            {
+                if (queue.Count == 0)
+                    return NoEvents(requestID, pAgentId);
+
+                lock (m_ids)
+                    thisID = m_ids[pAgentId];
+
+                if (thisID < 0)
+                {
+                    negativeID = true;
+                    thisID = -thisID;
+                }
+
+                while (queue.Count > 0)
+                {
+                    element = queue.Dequeue();
+                    // add elements until a marker is found
+                    // so they get into a response
+                    if (element == null)
+                        break;
+                    if (DebugLevel > 0)
+                        LogOutboundDebugMessage(element, pAgentId);
+                    array.Add(element);
+                    thisID++;
+                }
+            }
+
+            OSDMap events = null;
+
+            if (array.Count > 0)
+            {
+                events = new OSDMap();
+                events.Add("events", array);
+                events.Add("id", new OSDInteger(thisID));
+            }
+
+            if (negativeID && element == null)
+            {
+                Random rnd = new Random(Environment.TickCount);
+                thisID = rnd.Next(30000000);
+                if (thisID < 0)
+                    thisID = -thisID;
+            }
+
+            lock (m_ids)
+            {
+                m_ids[pAgentId] = thisID + 1;
+            }
+
+            // if there where no elements before a marker send a NoEvents
+            if (array.Count == 0)
+                return NoEvents(requestID, pAgentId);
+
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 200;
+            responsedata["content_type"] = "application/xml";
+            responsedata["keepalive"] = false;
+            responsedata["reusecontext"] = false;
+            responsedata["str_response_string"] = OSDParser.SerializeLLSDXmlString(events);
+            //m_log.DebugFormat("[EVENTQUEUE]: sending response for {0} in region {1}: {2}", pAgentId, m_scene.RegionInfo.RegionName, responsedata["str_response_string"]);
+            return responsedata;
+        }
+
+        public Hashtable NoEvents(UUID requestID, UUID agentID)
+        {
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 502;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["reusecontext"] = false;
+            responsedata["str_response_string"] = "<llsd></llsd>";
+            responsedata["error_status_text"] = "<llsd></llsd>";
+            responsedata["http_protocol_version"] = "HTTP/1.0";
+            return responsedata;
+        }
+/* this is not a event message
+        public void DisableSimulator(ulong handle, UUID avatarID)
+        {
+            OSD item = EventQueueHelper.DisableSimulator(handle);
+            Enqueue(item, avatarID);
+        }
+*/
+        public virtual void EnableSimulator(ulong handle, IPEndPoint endPoint, UUID avatarID, int regionSizeX, int regionSizeY)
+        {
+            if (DebugLevel > 0)
+                m_log.DebugFormat("{0} EnableSimulator. handle={1}, endPoint={2}, avatarID={3}",
+                    LogHeader, handle, endPoint, avatarID, regionSizeX, regionSizeY);
+
+            OSD item = EventQueueHelper.EnableSimulator(handle, endPoint, regionSizeX, regionSizeY);
+            Enqueue(item, avatarID);
+        }
+
+        public virtual void EstablishAgentCommunication(UUID avatarID, IPEndPoint endPoint, string capsPath,
+                                ulong regionHandle, int regionSizeX, int regionSizeY)
+        {
+            if (DebugLevel > 0)
+                m_log.DebugFormat("{0} EstablishAgentCommunication. handle={1}, endPoint={2}, avatarID={3}",
+                    LogHeader, regionHandle, endPoint, avatarID, regionSizeX, regionSizeY);
+
+            OSD item = EventQueueHelper.EstablishAgentCommunication(avatarID, endPoint.ToString(), capsPath, regionHandle, regionSizeX, regionSizeY);
+            Enqueue(item, avatarID);
+        }
+
+        public virtual void TeleportFinishEvent(ulong regionHandle, byte simAccess,
+                                        IPEndPoint regionExternalEndPoint,
+                                        uint locationID, uint flags, string capsURL,
+                                        UUID avatarID, int regionSizeX, int regionSizeY)
+        {
+            if (DebugLevel > 0)
+                m_log.DebugFormat("{0} TeleportFinishEvent. handle={1}, endPoint={2}, avatarID={3}",
+                    LogHeader, regionHandle, regionExternalEndPoint, avatarID, regionSizeX, regionSizeY);
+
+            OSD item = EventQueueHelper.TeleportFinishEvent(regionHandle, simAccess, regionExternalEndPoint,
+                                                            locationID, flags, capsURL, avatarID, regionSizeX, regionSizeY);
+            Enqueue(item, avatarID);
+        }
+
+        public virtual void CrossRegion(ulong handle, Vector3 pos, Vector3 lookAt,
+                                IPEndPoint newRegionExternalEndPoint,
+                                string capsURL, UUID avatarID, UUID sessionID, int regionSizeX, int regionSizeY)
+        {
+            if (DebugLevel > 0)
+                m_log.DebugFormat("{0} CrossRegion. handle={1}, avatarID={2}, regionSize={3},{4}>",
+                    LogHeader, handle, avatarID, regionSizeX, regionSizeY);
+
+            OSD item = EventQueueHelper.CrossRegion(handle, pos, lookAt, newRegionExternalEndPoint,
+                                                    capsURL, avatarID, sessionID, regionSizeX, regionSizeY);
+            Enqueue(item, avatarID);
+        }
+
+        public void ChatterboxInvitation(UUID sessionID, string sessionName,
+                                         UUID fromAgent, string message, UUID toAgent, string fromName, byte dialog,
+                                         uint timeStamp, bool offline, int parentEstateID, Vector3 position,
+                                         uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket)
+        {
+            OSD item = EventQueueHelper.ChatterboxInvitation(sessionID, sessionName, fromAgent, message, toAgent, fromName, dialog,
+                                                             timeStamp, offline, parentEstateID, position, ttl, transactionID,
+                                                             fromGroup, binaryBucket);
+            Enqueue(item, toAgent);
+            //m_log.InfoFormat("########### eq ChatterboxInvitation #############\n{0}", item);
+
+        }
+
+        public void ChatterBoxSessionAgentListUpdates(UUID sessionID, UUID fromAgent, UUID toAgent, bool canVoiceChat,
+                                                      bool isModerator, bool textMute, bool isEnterorLeave)
+        {
+            OSD item = EventQueueHelper.ChatterBoxSessionAgentListUpdates(sessionID, fromAgent, canVoiceChat,
+                                                                          isModerator, textMute, isEnterorLeave);
+            Enqueue(item, toAgent);
+            //m_log.InfoFormat("########### eq ChatterBoxSessionAgentListUpdates #############\n{0}", item);
+        }
+
+        public void ChatterBoxForceClose(UUID toAgent, UUID sessionID, string reason)
+        {
+            OSD item = EventQueueHelper.ChatterBoxForceClose(sessionID, reason);
+
+            Enqueue(item, toAgent);
+        }
+
+        public void ParcelProperties(ParcelPropertiesMessage parcelPropertiesMessage, UUID avatarID)
+        {
+            OSD item = EventQueueHelper.ParcelProperties(parcelPropertiesMessage);
+            Enqueue(item, avatarID);
+        }
+
+        public void GroupMembershipData(UUID receiverAgent, GroupMembershipData[] data)
+        {
+            OSD item = EventQueueHelper.GroupMembershipData(receiverAgent, data);
+            Enqueue(item, receiverAgent);
+        }
+
+        public void QueryReply(PlacesReplyPacket groupUpdate, UUID avatarID)
+        {
+            OSD item = EventQueueHelper.PlacesQuery(groupUpdate);
+            Enqueue(item, avatarID);
+        }
+
+        public OSD ScriptRunningEvent(UUID objectID, UUID itemID, bool running, bool mono)
+        {
+            return EventQueueHelper.ScriptRunningReplyEvent(objectID, itemID, running, mono);
+        }
+
+        public OSD BuildEvent(string eventName, OSD eventBody)
+        {
+            return EventQueueHelper.BuildEvent(eventName, eventBody);
+        }
+
+        public void partPhysicsProperties(uint localID, byte physhapetype,
+                        float density, float friction, float bounce, float gravmod,UUID avatarID)
+        {
+            OSD item = EventQueueHelper.partPhysicsProperties(localID, physhapetype,
+                        density, friction, bounce, gravmod);
+            Enqueue(item, avatarID);
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
new file mode 100644
index 0000000..461f776
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
@@ -0,0 +1,465 @@
+/*
+ * 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.Net;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Messages.Linden;
+
+using OpenSim.Framework;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public class EventQueueHelper
+    {
+        private EventQueueHelper() {} // no construction possible, it's an utility class
+
+        private static byte[] ulongToByteArray(ulong uLongValue)
+        {
+            // Reverse endianness of RegionHandle
+            return new byte[]
+            {
+                (byte)((uLongValue >> 56) % 256),
+                (byte)((uLongValue >> 48) % 256),
+                (byte)((uLongValue >> 40) % 256),
+                (byte)((uLongValue >> 32) % 256),
+                (byte)((uLongValue >> 24) % 256),
+                (byte)((uLongValue >> 16) % 256),
+                (byte)((uLongValue >> 8) % 256),
+                (byte)(uLongValue % 256)
+            };
+        }
+
+//        private static byte[] uintToByteArray(uint uIntValue)
+//        {
+//            byte[] result = new byte[4];
+//            Utils.UIntToBytesBig(uIntValue, result, 0);
+//            return result;
+//        }
+
+        public static OSD BuildEvent(string eventName, OSD eventBody)
+        {
+            OSDMap llsdEvent = new OSDMap(2);
+            llsdEvent.Add("message", new OSDString(eventName));
+            llsdEvent.Add("body", eventBody);
+
+            return llsdEvent;
+        }
+
+        public static OSD EnableSimulator(ulong handle, IPEndPoint endPoint, int regionSizeX, int regionSizeY)
+        {
+            OSDMap llsdSimInfo = new OSDMap(5);
+
+            llsdSimInfo.Add("Handle", new OSDBinary(ulongToByteArray(handle)));
+            llsdSimInfo.Add("IP", new OSDBinary(endPoint.Address.GetAddressBytes()));
+            llsdSimInfo.Add("Port", OSD.FromInteger(endPoint.Port));
+            llsdSimInfo.Add("RegionSizeX", OSD.FromUInteger((uint)regionSizeX));
+            llsdSimInfo.Add("RegionSizeY", OSD.FromUInteger((uint)regionSizeY));
+
+            OSDArray arr = new OSDArray(1);
+            arr.Add(llsdSimInfo);
+
+            OSDMap llsdBody = new OSDMap(1);
+            llsdBody.Add("SimulatorInfo", arr);
+
+            return BuildEvent("EnableSimulator", llsdBody);
+        }
+/*
+        public static OSD DisableSimulator(ulong handle)
+        {
+            //OSDMap llsdSimInfo = new OSDMap(1);
+
+            //llsdSimInfo.Add("Handle", new OSDBinary(regionHandleToByteArray(handle)));
+
+            //OSDArray arr = new OSDArray(1);
+            //arr.Add(llsdSimInfo);
+
+            OSDMap llsdBody = new OSDMap(0);
+            //llsdBody.Add("SimulatorInfo", arr);
+
+            return BuildEvent("DisableSimulator", llsdBody);
+        }
+*/
+        public static OSD CrossRegion(ulong handle, Vector3 pos, Vector3 lookAt,
+                                      IPEndPoint newRegionExternalEndPoint,
+                                      string capsURL, UUID agentID, UUID sessionID,
+                                      int regionSizeX, int regionSizeY)
+        {
+            OSDArray lookAtArr = new OSDArray(3);
+            lookAtArr.Add(OSD.FromReal(lookAt.X));
+            lookAtArr.Add(OSD.FromReal(lookAt.Y));
+            lookAtArr.Add(OSD.FromReal(lookAt.Z));
+
+            OSDArray positionArr = new OSDArray(3);
+            positionArr.Add(OSD.FromReal(pos.X));
+            positionArr.Add(OSD.FromReal(pos.Y));
+            positionArr.Add(OSD.FromReal(pos.Z));
+
+            OSDMap infoMap = new OSDMap(2);
+            infoMap.Add("LookAt", lookAtArr);
+            infoMap.Add("Position", positionArr);
+
+            OSDArray infoArr = new OSDArray(1);
+            infoArr.Add(infoMap);
+
+            OSDMap agentDataMap = new OSDMap(2);
+            agentDataMap.Add("AgentID", OSD.FromUUID(agentID));
+            agentDataMap.Add("SessionID",  OSD.FromUUID(sessionID));
+
+            OSDArray agentDataArr = new OSDArray(1);
+            agentDataArr.Add(agentDataMap);
+
+            OSDMap regionDataMap = new OSDMap(6);
+            regionDataMap.Add("RegionHandle", OSD.FromBinary(ulongToByteArray(handle)));
+            regionDataMap.Add("SeedCapability", OSD.FromString(capsURL));
+            regionDataMap.Add("SimIP", OSD.FromBinary(newRegionExternalEndPoint.Address.GetAddressBytes()));
+            regionDataMap.Add("SimPort", OSD.FromInteger(newRegionExternalEndPoint.Port));
+            regionDataMap.Add("RegionSizeX", OSD.FromUInteger((uint)regionSizeX));
+            regionDataMap.Add("RegionSizeY", OSD.FromUInteger((uint)regionSizeY));
+
+            OSDArray regionDataArr = new OSDArray(1);
+            regionDataArr.Add(regionDataMap);
+
+            OSDMap llsdBody = new OSDMap(3);
+            llsdBody.Add("Info", infoArr);
+            llsdBody.Add("AgentData", agentDataArr);
+            llsdBody.Add("RegionData", regionDataArr);
+
+            return BuildEvent("CrossedRegion", llsdBody);
+        }
+
+        public static OSD TeleportFinishEvent(
+                        ulong regionHandle, byte simAccess, IPEndPoint regionExternalEndPoint,
+                        uint locationID, uint flags, string capsURL, UUID agentID,
+                        int regionSizeX, int regionSizeY)
+        {
+            // not sure why flags get overwritten here
+            if ((flags & (uint)TeleportFlags.IsFlying) != 0)
+                flags = (uint)TeleportFlags.ViaLocation | (uint)TeleportFlags.IsFlying;
+            else
+                flags = (uint)TeleportFlags.ViaLocation;
+
+            OSDMap info = new OSDMap();
+            info.Add("AgentID", OSD.FromUUID(agentID));
+            info.Add("LocationID", OSD.FromInteger(4)); // TODO what is this?
+            info.Add("RegionHandle", OSD.FromBinary(ulongToByteArray(regionHandle)));
+            info.Add("SeedCapability", OSD.FromString(capsURL));
+            info.Add("SimAccess", OSD.FromInteger(simAccess));
+            info.Add("SimIP", OSD.FromBinary(regionExternalEndPoint.Address.GetAddressBytes()));
+            info.Add("SimPort", OSD.FromInteger(regionExternalEndPoint.Port));
+//            info.Add("TeleportFlags", OSD.FromULong(1L << 4)); // AgentManager.TeleportFlags.ViaLocation
+            info.Add("TeleportFlags", OSD.FromUInteger(flags));
+            info.Add("RegionSizeX", OSD.FromUInteger((uint)regionSizeX));
+            info.Add("RegionSizeY", OSD.FromUInteger((uint)regionSizeY));
+
+            OSDArray infoArr = new OSDArray();
+            infoArr.Add(info);
+
+            OSDMap body = new OSDMap();
+            body.Add("Info", infoArr);
+
+            return BuildEvent("TeleportFinish", body);
+        }
+
+        public static OSD ScriptRunningReplyEvent(UUID objectID, UUID itemID, bool running, bool mono)
+        {
+            OSDMap script = new OSDMap();
+            script.Add("ObjectID", OSD.FromUUID(objectID));
+            script.Add("ItemID", OSD.FromUUID(itemID));
+            script.Add("Running", OSD.FromBoolean(running));
+            script.Add("Mono", OSD.FromBoolean(mono));
+
+            OSDArray scriptArr = new OSDArray();
+            scriptArr.Add(script);
+
+            OSDMap body = new OSDMap();
+            body.Add("Script", scriptArr);
+
+            return BuildEvent("ScriptRunningReply", body);
+        }
+
+        public static OSD EstablishAgentCommunication(UUID agentID, string simIpAndPort, string seedcap,
+                                    ulong regionHandle, int regionSizeX, int regionSizeY)
+        {
+            OSDMap body = new OSDMap(6)
+                              {
+                                  {"agent-id", new OSDUUID(agentID)},
+                                  {"sim-ip-and-port", new OSDString(simIpAndPort)},
+                                  {"seed-capability", new OSDString(seedcap)},
+                                  {"region-handle", OSD.FromULong(regionHandle)},
+                                  {"region-size-x", OSD.FromUInteger((uint)regionSizeX)},
+                                  {"region-size-y", OSD.FromUInteger((uint)regionSizeY)}
+                              };
+
+            return BuildEvent("EstablishAgentCommunication", body);
+        }
+
+        public static OSD KeepAliveEvent()
+        {
+            return BuildEvent("FAKEEVENT", new OSDMap());
+        }
+
+        public static OSD AgentParams(UUID agentID, bool checkEstate, int godLevel, bool limitedToEstate)
+        {
+            OSDMap body = new OSDMap(4);
+
+            body.Add("agent_id", new OSDUUID(agentID));
+            body.Add("check_estate", new OSDInteger(checkEstate ? 1 : 0));
+            body.Add("god_level", new OSDInteger(godLevel));
+            body.Add("limited_to_estate", new OSDInteger(limitedToEstate ? 1 : 0));
+
+            return body;
+        }
+
+        public static OSD InstantMessageParams(UUID fromAgent, string message, UUID toAgent,
+            string fromName, byte dialog, uint timeStamp, bool offline, int parentEstateID,
+            Vector3 position, uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket)
+        {
+            OSDMap messageParams = new OSDMap(15);
+            messageParams.Add("type", new OSDInteger((int)dialog));
+
+            OSDArray positionArray = new OSDArray(3);
+            positionArray.Add(OSD.FromReal(position.X));
+            positionArray.Add(OSD.FromReal(position.Y));
+            positionArray.Add(OSD.FromReal(position.Z));
+            messageParams.Add("position", positionArray);
+
+            messageParams.Add("region_id", new OSDUUID(UUID.Zero));
+            messageParams.Add("to_id", new OSDUUID(toAgent));
+            messageParams.Add("source", new OSDInteger(0));
+
+            OSDMap data = new OSDMap(1);
+            data.Add("binary_bucket", OSD.FromBinary(binaryBucket));
+            messageParams.Add("data", data);
+            messageParams.Add("message", new OSDString(message));
+            messageParams.Add("id", new OSDUUID(transactionID));
+            messageParams.Add("from_name", new OSDString(fromName));
+            messageParams.Add("timestamp", new OSDInteger((int)timeStamp));
+            messageParams.Add("offline", new OSDInteger(offline ? 1 : 0));
+            messageParams.Add("parent_estate_id", new OSDInteger(parentEstateID));
+            messageParams.Add("ttl", new OSDInteger((int)ttl));
+            messageParams.Add("from_id", new OSDUUID(fromAgent));
+            messageParams.Add("from_group", new OSDInteger(fromGroup ? 1 : 0));
+
+            return messageParams;
+        }
+
+        public static OSD InstantMessage(UUID fromAgent, string message, UUID toAgent,
+            string fromName, byte dialog, uint timeStamp, bool offline, int parentEstateID,
+            Vector3 position, uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket,
+            bool checkEstate, int godLevel, bool limitedToEstate)
+        {
+            OSDMap im = new OSDMap(2);
+            im.Add("message_params", InstantMessageParams(fromAgent, message, toAgent,
+            fromName, dialog, timeStamp, offline, parentEstateID,
+            position, ttl, transactionID, fromGroup, binaryBucket));
+
+            im.Add("agent_params", AgentParams(fromAgent, checkEstate, godLevel, limitedToEstate));
+
+            return im;
+        }
+
+
+        public static OSD ChatterboxInvitation(UUID sessionID, string sessionName,
+            UUID fromAgent, string message, UUID toAgent, string fromName, byte dialog,
+            uint timeStamp, bool offline, int parentEstateID, Vector3 position,
+            uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket)
+        {
+            OSDMap body = new OSDMap(5);
+            body.Add("session_id", new OSDUUID(sessionID));
+            body.Add("from_name", new OSDString(fromName));
+            body.Add("session_name", new OSDString(sessionName));
+            body.Add("from_id", new OSDUUID(fromAgent));
+
+            body.Add("instantmessage", InstantMessage(fromAgent, message, toAgent,
+            fromName, dialog, timeStamp, offline, parentEstateID, position,
+            ttl, transactionID, fromGroup, binaryBucket, true, 0, true));
+
+            OSDMap chatterboxInvitation = new OSDMap(2);
+            chatterboxInvitation.Add("message", new OSDString("ChatterBoxInvitation"));
+            chatterboxInvitation.Add("body", body);
+            return chatterboxInvitation;
+        }
+
+        public static OSD ChatterBoxSessionAgentListUpdates(UUID sessionID,
+            UUID agentID, bool canVoiceChat, bool isModerator, bool textMute, bool isEnterorLeave)
+        {
+            OSDMap body = new OSDMap();
+            OSDMap agentUpdates = new OSDMap();
+            OSDMap infoDetail = new OSDMap();
+            OSDMap mutes = new OSDMap();
+
+            // this should be a list of agents and parameters
+            // foreach agent
+            mutes.Add("text", OSD.FromBoolean(textMute));
+            infoDetail.Add("can_voice_chat", OSD.FromBoolean(canVoiceChat));
+            infoDetail.Add("is_moderator", OSD.FromBoolean(isModerator));
+            infoDetail.Add("mutes", mutes);
+            OSDMap info = new OSDMap();
+            info.Add("info", infoDetail);
+            if(isEnterorLeave)
+                info.Add("transition",OSD.FromString("ENTER"));
+            else
+                info.Add("transition",OSD.FromString("LEAVE"));
+            agentUpdates.Add(agentID.ToString(), info);
+
+            // foreach end
+
+            body.Add("agent_updates", agentUpdates);
+            body.Add("session_id", OSD.FromUUID(sessionID));
+            body.Add("updates", new OSD());
+
+            OSDMap chatterBoxSessionAgentListUpdates = new OSDMap();
+            chatterBoxSessionAgentListUpdates.Add("message", OSD.FromString("ChatterBoxSessionAgentListUpdates"));
+            chatterBoxSessionAgentListUpdates.Add("body", body);
+
+            return chatterBoxSessionAgentListUpdates;
+        }
+
+        public static OSD ChatterBoxForceClose(UUID sessionID, string reason)
+        {
+            OSDMap body = new OSDMap(2);
+            body.Add("session_id", new OSDUUID(sessionID));
+            body.Add("reason", new OSDString(reason));
+
+            OSDMap chatterBoxForceClose = new OSDMap(2);
+            chatterBoxForceClose.Add("message", new OSDString("ForceCloseChatterBoxSession"));
+            chatterBoxForceClose.Add("body", body);
+            return chatterBoxForceClose;
+        }
+
+        public static OSD GroupMembershipData(UUID receiverAgent, GroupMembershipData[] data)
+        {
+            OSDArray AgentData = new OSDArray(1);
+            OSDMap AgentDataMap = new OSDMap(1);
+            AgentDataMap.Add("AgentID", OSD.FromUUID(receiverAgent));
+            AgentData.Add(AgentDataMap);
+
+            OSDArray GroupData = new OSDArray(data.Length);
+            OSDArray NewGroupData = new OSDArray(data.Length);
+
+            foreach (GroupMembershipData membership in data)
+            {
+                OSDMap GroupDataMap = new OSDMap(6);
+                OSDMap NewGroupDataMap = new OSDMap(1);
+
+                GroupDataMap.Add("GroupID", OSD.FromUUID(membership.GroupID));
+                GroupDataMap.Add("GroupPowers", OSD.FromULong(membership.GroupPowers));
+                GroupDataMap.Add("AcceptNotices", OSD.FromBoolean(membership.AcceptNotices));
+                GroupDataMap.Add("GroupInsigniaID", OSD.FromUUID(membership.GroupPicture));
+                GroupDataMap.Add("Contribution", OSD.FromInteger(membership.Contribution));
+                GroupDataMap.Add("GroupName", OSD.FromString(membership.GroupName));
+                NewGroupDataMap.Add("ListInProfile", OSD.FromBoolean(membership.ListInProfile));
+
+                GroupData.Add(GroupDataMap);
+                NewGroupData.Add(NewGroupDataMap);
+            }
+
+            OSDMap llDataStruct = new OSDMap(3);
+            llDataStruct.Add("AgentData", AgentData);
+            llDataStruct.Add("GroupData", GroupData);
+            llDataStruct.Add("NewGroupData", NewGroupData);
+
+            return BuildEvent("AgentGroupDataUpdate", llDataStruct);
+
+        }
+
+        public static OSD PlacesQuery(PlacesReplyPacket PlacesReply)
+        {
+            OSDMap placesReply = new OSDMap();
+            placesReply.Add("message", OSD.FromString("PlacesReplyMessage"));
+
+            OSDMap body = new OSDMap();
+            OSDArray agentData = new OSDArray();
+            OSDMap agentDataMap = new OSDMap();
+            agentDataMap.Add("AgentID", OSD.FromUUID(PlacesReply.AgentData.AgentID));
+            agentDataMap.Add("QueryID", OSD.FromUUID(PlacesReply.AgentData.QueryID));
+            agentDataMap.Add("TransactionID", OSD.FromUUID(PlacesReply.TransactionData.TransactionID));
+            agentData.Add(agentDataMap);
+            body.Add("AgentData", agentData);
+
+            OSDArray QueryData = new OSDArray();
+
+            foreach (PlacesReplyPacket.QueryDataBlock groupDataBlock in PlacesReply.QueryData)
+            {
+                OSDMap QueryDataMap = new OSDMap();
+                QueryDataMap.Add("ActualArea", OSD.FromInteger(groupDataBlock.ActualArea));
+                QueryDataMap.Add("BillableArea", OSD.FromInteger(groupDataBlock.BillableArea));
+                QueryDataMap.Add("Description", OSD.FromBinary(groupDataBlock.Desc));
+                QueryDataMap.Add("Dwell", OSD.FromInteger((int)groupDataBlock.Dwell));
+                QueryDataMap.Add("Flags", OSD.FromString(Convert.ToString(groupDataBlock.Flags)));
+                QueryDataMap.Add("GlobalX", OSD.FromInteger((int)groupDataBlock.GlobalX));
+                QueryDataMap.Add("GlobalY", OSD.FromInteger((int)groupDataBlock.GlobalY));
+                QueryDataMap.Add("GlobalZ", OSD.FromInteger((int)groupDataBlock.GlobalZ));
+                QueryDataMap.Add("Name", OSD.FromBinary(groupDataBlock.Name));
+                QueryDataMap.Add("OwnerID", OSD.FromUUID(groupDataBlock.OwnerID));
+                QueryDataMap.Add("SimName", OSD.FromBinary(groupDataBlock.SimName));
+                QueryDataMap.Add("SnapShotID", OSD.FromUUID(groupDataBlock.SnapshotID));
+                QueryDataMap.Add("ProductSku", OSD.FromInteger(0));
+                QueryDataMap.Add("Price", OSD.FromInteger(groupDataBlock.Price));
+
+                QueryData.Add(QueryDataMap);
+            }
+            body.Add("QueryData", QueryData);
+            placesReply.Add("QueryData[]", body);
+
+            return placesReply;
+        }
+
+        public static OSD ParcelProperties(ParcelPropertiesMessage parcelPropertiesMessage)
+        {
+            OSDMap message = new OSDMap();
+            message.Add("message", OSD.FromString("ParcelProperties"));
+            OSD message_body = parcelPropertiesMessage.Serialize();
+            message.Add("body", message_body);
+            return message;
+        }
+
+        public static OSD partPhysicsProperties(uint localID, byte physhapetype,
+                        float density, float friction, float bounce, float gravmod)
+        {
+
+            OSDMap physinfo = new OSDMap(6);
+            physinfo["LocalID"] = localID;
+            physinfo["Density"] = density;
+            physinfo["Friction"] = friction;
+            physinfo["GravityMultiplier"] = gravmod;
+            physinfo["Restitution"] = bounce;
+            physinfo["PhysicsShapeType"] = (int)physhapetype;
+
+            OSDArray array = new OSDArray(1);
+            array.Add(physinfo);
+
+            OSDMap llsdBody = new OSDMap(1);
+            llsdBody.Add("ObjectData", array);
+
+            return BuildEvent("ObjectPhysicsProperties", llsdBody);
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs
new file mode 100644
index 0000000..ee3f4f1
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs
@@ -0,0 +1,198 @@
+/*
+ * 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.Net;
+using log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.ClientStack.Linden;
+using OpenSim.Region.CoreModules.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.OptionalModules.World.NPC;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.Linden.Tests
+{
+    [TestFixture]
+    public class EventQueueTests : OpenSimTestCase
+    {
+        private TestScene m_scene;
+        private EventQueueGetModule m_eqgMod;
+        private NPCModule m_npcMod;
+
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            uint port = 9999;
+            uint sslPort = 9998;
+
+            // This is an unfortunate bit of clean up we have to do because MainServer manages things through static
+            // variables and the VM is not restarted between tests.
+            MainServer.RemoveHttpServer(port);
+
+            BaseHttpServer server = new BaseHttpServer(port, false, sslPort, "");
+            MainServer.AddHttpServer(server);
+            MainServer.Instance = server;
+
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Startup");
+
+            CapabilitiesModule capsModule = new CapabilitiesModule();
+            m_eqgMod = new EventQueueGetModule();
+
+            // For NPC test support
+            config.AddConfig("NPC");
+            config.Configs["NPC"].Set("Enabled", "true");
+            m_npcMod = new NPCModule();
+
+            m_scene = new SceneHelpers().SetupScene();
+            SceneHelpers.SetupSceneModules(m_scene, config, capsModule, m_eqgMod, m_npcMod);
+        }
+
+        [Test]
+        public void TestAddForClient()
+        {
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            SceneHelpers.AddScenePresence(m_scene, TestHelpers.ParseTail(0x1));
+
+            // TODO: Add more assertions for the other aspects of event queues
+            Assert.That(MainServer.Instance.GetPollServiceHandlerKeys().Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestRemoveForClient()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            UUID spId = TestHelpers.ParseTail(0x1);
+
+            SceneHelpers.AddScenePresence(m_scene, spId);
+            m_scene.CloseAgent(spId, false);
+
+            // TODO: Add more assertions for the other aspects of event queues
+            Assert.That(MainServer.Instance.GetPollServiceHandlerKeys().Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void TestEnqueueMessage()
+        {
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            ScenePresence sp = SceneHelpers.AddScenePresence(m_scene, TestHelpers.ParseTail(0x1));
+
+            string messageName = "TestMessage";
+
+            m_eqgMod.Enqueue(m_eqgMod.BuildEvent(messageName, new OSDMap()), sp.UUID);
+
+            Hashtable eventsResponse = m_eqgMod.GetEvents(UUID.Zero, sp.UUID);
+
+            // initial queue as null events
+            eventsResponse = m_eqgMod.GetEvents(UUID.Zero, sp.UUID);
+            if((int)eventsResponse["int_response_code"] != (int)HttpStatusCode.OK)
+            {
+                eventsResponse = m_eqgMod.GetEvents(UUID.Zero, sp.UUID);
+                if((int)eventsResponse["int_response_code"] != (int)HttpStatusCode.OK)
+                    eventsResponse = m_eqgMod.GetEvents(UUID.Zero, sp.UUID);
+            }
+
+            Assert.That((int)eventsResponse["int_response_code"], Is.EqualTo((int)HttpStatusCode.OK));
+
+//            Console.WriteLine("Response [{0}]", (string)eventsResponse["str_response_string"]);
+
+            OSDMap rawOsd = (OSDMap)OSDParser.DeserializeLLSDXml((string)eventsResponse["str_response_string"]);
+            OSDArray eventsOsd = (OSDArray)rawOsd["events"];
+
+            bool foundUpdate = false;
+            foreach (OSD osd in eventsOsd)
+            {
+                OSDMap eventOsd = (OSDMap)osd;
+
+                if (eventOsd["message"] == messageName)
+                    foundUpdate = true;
+            }
+
+            Assert.That(foundUpdate, Is.True, string.Format("Did not find {0} in response", messageName));
+        }
+
+        /// <summary>
+        /// Test an attempt to put a message on the queue of a user that is not in the region.
+        /// </summary>
+        [Test]
+        public void TestEnqueueMessageNoUser()
+        {
+            TestHelpers.InMethod();
+            TestHelpers.EnableLogging();
+
+            string messageName = "TestMessage";
+
+            m_eqgMod.Enqueue(m_eqgMod.BuildEvent(messageName, new OSDMap()), TestHelpers.ParseTail(0x1));
+
+            Hashtable eventsResponse = m_eqgMod.GetEvents(UUID.Zero, TestHelpers.ParseTail(0x1));
+
+            Assert.That((int)eventsResponse["int_response_code"], Is.EqualTo((int)HttpStatusCode.BadGateway));
+        }
+
+        /// <summary>
+        /// NPCs do not currently have an event queue but a caller may try to send a message anyway, so check behaviour.
+        /// </summary>
+        [Test]
+        public void TestEnqueueMessageToNpc()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            UUID npcId
+                = m_npcMod.CreateNPC(
+                    "John", "Smith", new Vector3(128, 128, 30), UUID.Zero, true, m_scene, new AvatarAppearance());
+
+            ScenePresence npc = m_scene.GetScenePresence(npcId);
+
+            string messageName = "TestMessage";
+
+            m_eqgMod.Enqueue(m_eqgMod.BuildEvent(messageName, new OSDMap()), npc.UUID);
+
+            Hashtable eventsResponse = m_eqgMod.GetEvents(UUID.Zero, npc.UUID);
+
+            Assert.That((int)eventsResponse["int_response_code"], Is.EqualTo((int)HttpStatusCode.BadGateway));
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/FetchInventory2Module.cs b/OpenSim/Region/ClientStack/Linden/Caps/FetchInventory2Module.cs
new file mode 100644
index 0000000..e0a11cc
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/FetchInventory2Module.cs
@@ -0,0 +1,144 @@
+/*
+ * 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 Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using System;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    /// <summary>
+    /// This module implements both WebFetchInventoryDescendents and FetchInventoryDescendents2 capabilities.
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "FetchInventory2Module")]
+    public class FetchInventory2Module : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public bool Enabled { get; private set; }
+
+        private Scene m_scene;
+
+        private IInventoryService m_inventoryService;
+
+        private string m_fetchInventory2Url;
+
+        #region ISharedRegionModule Members
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_fetchInventory2Url = config.GetString("Cap_FetchInventory2", string.Empty);
+
+            if (m_fetchInventory2Url != string.Empty)
+                Enabled = true;
+        }
+
+        public void AddRegion(Scene s)
+        {
+            if (!Enabled)
+                return;
+
+            m_scene = s;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            if (!Enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            if (!Enabled)
+                return;
+
+            m_inventoryService = m_scene.InventoryService;
+
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void PostInitialise() {}
+
+        public void Close() {}
+
+        public string Name { get { return "FetchInventory2Module"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        private void RegisterCaps(UUID agentID, Caps caps)
+        {
+            RegisterFetchCap(agentID, caps, "FetchInventory2", m_fetchInventory2Url);
+        }
+
+        private void RegisterFetchCap(UUID agentID, Caps caps, string capName, string url)
+        {
+            string capUrl;
+
+            if (url == "localhost")
+            {
+                capUrl = "/CAPS/" + UUID.Random();
+
+                FetchInventory2Handler fetchHandler = new FetchInventory2Handler(m_inventoryService, agentID);
+
+                IRequestHandler reqHandler
+                    = new RestStreamHandler(
+                        "POST", capUrl, fetchHandler.FetchInventoryRequest, capName, agentID.ToString());
+
+                caps.RegisterHandler(capName, reqHandler);
+            }
+            else
+            {
+                capUrl = url;
+
+                caps.RegisterHandler(capName, capUrl);
+            }
+
+//            m_log.DebugFormat(
+//                "[FETCH INVENTORY2 MODULE]: Registered capability {0} at {1} in region {2} for {3}",
+//                capName, capUrl, m_scene.RegionInfo.RegionName, agentID);
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
new file mode 100644
index 0000000..ba917e39
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
@@ -0,0 +1,456 @@
+/*
+ * 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.Collections.Specialized;
+using System.Reflection;
+using System.IO;
+using System.Threading;
+using System.Web;
+using Mono.Addins;
+using OpenSim.Framework.Monitoring;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "GetMeshModule")]
+    public class GetMeshModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_scene;
+        private IAssetService m_AssetService;
+        private bool m_Enabled = true;
+        private string m_URL;
+
+        private string m_URL2;
+        private string m_RedirectURL = null;
+        private string m_RedirectURL2 = null;
+
+        struct aPollRequest
+        {
+            public PollServiceMeshEventArgs thepoll;
+            public UUID reqID;
+            public Hashtable request;
+        }
+
+        public class aPollResponse
+        {
+            public Hashtable response;
+            public int bytes;
+            public int lod;
+        }
+
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static GetMeshHandler m_getMeshHandler;
+
+        private IAssetService m_assetService = null;
+
+        private Dictionary<UUID, string> m_capsDict = new Dictionary<UUID, string>();
+        private static Thread[] m_workerThreads = null;
+        private static int m_NumberScenes = 0;
+        private static OpenSim.Framework.BlockingQueue<aPollRequest> m_queue =
+                new OpenSim.Framework.BlockingQueue<aPollRequest>();
+
+        private Dictionary<UUID, PollServiceMeshEventArgs> m_pollservices = new Dictionary<UUID, PollServiceMeshEventArgs>();
+
+
+        #region Region Module interfaceBase Members
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_URL = config.GetString("Cap_GetMesh", string.Empty);
+            // Cap doesn't exist
+            if (m_URL != string.Empty)
+            {
+                m_Enabled = true;
+                m_RedirectURL = config.GetString("GetMeshRedirectURL");
+            }
+
+            m_URL2 = config.GetString("Cap_GetMesh2", string.Empty);
+            // Cap doesn't exist
+            if (m_URL2 != string.Empty)
+            {
+                m_Enabled = true;
+
+                m_RedirectURL2 = config.GetString("GetMesh2RedirectURL");
+            }
+        }
+
+        public void AddRegion(Scene pScene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene = pScene;
+
+            m_assetService = pScene.AssetService;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps -= DeregisterCaps;
+            m_scene.EventManager.OnThrottleUpdate -= ThrottleUpdate;
+            m_NumberScenes--;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_AssetService = m_scene.RequestModuleInterface<IAssetService>();
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+            // We'll reuse the same handler for all requests.
+            m_getMeshHandler = new GetMeshHandler(m_assetService);
+            m_scene.EventManager.OnDeregisterCaps += DeregisterCaps;
+            m_scene.EventManager.OnThrottleUpdate += ThrottleUpdate;
+
+            m_NumberScenes++;
+
+            if (m_workerThreads == null)
+            {
+                m_workerThreads = new Thread[2];
+
+                for (uint i = 0; i < 2; i++)
+                {
+                    m_workerThreads[i] = WorkManager.StartThread(DoMeshRequests,
+                            String.Format("GetMeshWorker{0}", i),
+                            ThreadPriority.Normal,
+                            true,
+                            false,
+                            null,
+                            int.MaxValue);
+                }
+            }
+        }
+
+        public void Close()
+        {
+            if(m_NumberScenes <= 0 && m_workerThreads != null)
+            {
+                m_log.DebugFormat("[GetMeshModule] Closing");
+                foreach (Thread t in m_workerThreads)
+                    Watchdog.AbortThread(t.ManagedThreadId);
+                // This will fail on region shutdown. Its harmless.
+                // Prevent red ink.
+                try
+                {
+                    m_queue.Clear();
+                }
+                catch {}
+            }
+        }
+
+        public string Name { get { return "GetMeshModule"; } }
+
+        #endregion
+
+        private static void DoMeshRequests()
+        {
+            while(true)
+            {
+                aPollRequest poolreq = m_queue.Dequeue(4500);
+                Watchdog.UpdateThread();
+                if(m_NumberScenes <= 0)
+                    return;
+                if(poolreq.reqID != UUID.Zero)
+                    poolreq.thepoll.Process(poolreq);
+            }
+        }
+
+        // Now we know when the throttle is changed by the client in the case of a root agent or by a neighbor region in the case of a child agent.
+        public void ThrottleUpdate(ScenePresence p)
+        {
+            UUID user = p.UUID;
+            int imagethrottle = p.ControllingClient.GetAgentThrottleSilent((int)ThrottleOutPacketType.Asset);
+            PollServiceMeshEventArgs args;
+            if (m_pollservices.TryGetValue(user, out args))
+            {
+                args.UpdateThrottle(imagethrottle);
+            }
+        }
+
+        private class PollServiceMeshEventArgs : PollServiceEventArgs
+        {
+            private List<Hashtable> requests =
+                    new List<Hashtable>();
+            private Dictionary<UUID, aPollResponse> responses =
+                    new Dictionary<UUID, aPollResponse>();
+
+            private Scene m_scene;
+            private MeshCapsDataThrottler m_throttler;
+            public PollServiceMeshEventArgs(string uri, UUID pId, Scene scene) :
+                base(null, uri, null, null, null, pId, int.MaxValue)
+            {
+                m_scene = scene;
+                m_throttler = new MeshCapsDataThrottler(100000);
+                // x is request id, y is userid
+                HasEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        bool ret = m_throttler.hasEvents(x, responses);
+                        return ret;
+
+                    }
+                };
+                GetEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        try
+                        {
+                            return responses[x].response;
+                        }
+                        finally
+                        {
+                            responses.Remove(x);
+                            m_throttler.PassTime();
+                        }
+                    }
+                };
+                // x is request id, y is request data hashtable
+                Request = (x, y) =>
+                {
+                    aPollRequest reqinfo = new aPollRequest();
+                    reqinfo.thepoll = this;
+                    reqinfo.reqID = x;
+                    reqinfo.request = y;
+
+                    m_queue.Enqueue(reqinfo);
+                    m_throttler.PassTime();
+                };
+
+                // this should never happen except possible on shutdown
+                NoEvents = (x, y) =>
+                {
+                    /*
+                                        lock (requests)
+                                        {
+                                            Hashtable request = requests.Find(id => id["RequestID"].ToString() == x.ToString());
+                                            requests.Remove(request);
+                                        }
+                    */
+                    Hashtable response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    return response;
+                };
+            }
+
+            public void Process(aPollRequest requestinfo)
+            {
+                Hashtable response;
+
+                UUID requestID = requestinfo.reqID;
+
+                if(m_scene.ShuttingDown)
+                    return;
+
+                // If the avatar is gone, don't bother to get the texture
+                if (m_scene.GetScenePresence(Id) == null)
+                {
+                    response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    lock (responses)
+                        responses[requestID] = new aPollResponse() { bytes = 0, response = response, lod = 0 };
+
+                    return;
+                }
+
+                response = m_getMeshHandler.Handle(requestinfo.request);
+                lock (responses)
+                {
+                    responses[requestID] = new aPollResponse()
+                    {
+                        bytes = (int)response["int_bytes"],
+                        lod = (int)response["int_lod"],
+                        response = response
+                    };
+
+                }
+                m_throttler.PassTime();
+            }
+
+            internal void UpdateThrottle(int pthrottle)
+            {
+                int tmp = 2 * pthrottle;
+                if(tmp < 10000)
+                    tmp = 10000;
+                m_throttler.ThrottleBytes = tmp;
+            }
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+//            UUID capID = UUID.Random();
+            if (m_URL == "localhost")
+            {
+                string capUrl = "/CAPS/" + UUID.Random() + "/";
+
+                // Register this as a poll service
+                PollServiceMeshEventArgs args = new PollServiceMeshEventArgs(capUrl, agentID, m_scene);
+
+                args.Type = PollServiceEventArgs.EventType.Mesh;
+                MainServer.Instance.AddPollServiceHTTPHandler(capUrl, args);
+
+                string hostName = m_scene.RegionInfo.ExternalHostName;
+                uint port = (MainServer.Instance == null) ? 0 : MainServer.Instance.Port;
+                string protocol = "http";
+
+                if (MainServer.Instance.UseSSL)
+                {
+                    hostName = MainServer.Instance.SSLCommonName;
+                    port = MainServer.Instance.SSLPort;
+                    protocol = "https";
+                }
+                caps.RegisterHandler("GetMesh", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
+                m_pollservices[agentID] = args;
+                m_capsDict[agentID] = capUrl;
+            }
+            else
+            {
+                caps.RegisterHandler("GetMesh", m_URL);
+            }
+        }
+
+        private void DeregisterCaps(UUID agentID, Caps caps)
+        {
+            string capUrl;
+            PollServiceMeshEventArgs args;
+            if (m_capsDict.TryGetValue(agentID, out capUrl))
+            {
+                MainServer.Instance.RemoveHTTPHandler("", capUrl);
+                m_capsDict.Remove(agentID);
+            }
+            if (m_pollservices.TryGetValue(agentID, out args))
+            {
+                m_pollservices.Remove(agentID);
+            }
+        }
+
+        internal sealed class MeshCapsDataThrottler
+        {
+            private double lastTimeElapsed = 0;
+            private double BytesSent = 0;
+
+            public MeshCapsDataThrottler(int pBytes)
+            {
+                if(pBytes < 10000)
+                    pBytes = 10000;
+                ThrottleBytes = pBytes;
+                lastTimeElapsed = Util.GetTimeStampMS();
+            }
+
+            public bool hasEvents(UUID key, Dictionary<UUID, aPollResponse> responses)
+            {
+                PassTime();
+                // Note, this is called IN LOCK
+                bool haskey = responses.ContainsKey(key);
+
+                if (!haskey)
+                {
+                    return false;
+                }
+                aPollResponse response;
+                if (responses.TryGetValue(key, out response))
+                {
+                    // Normal
+                    if (BytesSent <= ThrottleBytes)
+                    {
+                        BytesSent += response.bytes;
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                return haskey;
+            }
+
+            public void PassTime()
+            {
+                double currenttime = Util.GetTimeStampMS();
+                double timeElapsed = currenttime - lastTimeElapsed;
+                if(timeElapsed < 50.0)
+                    return;
+                int add = (int)(ThrottleBytes * timeElapsed * 0.001);
+                if (add >= 1000)
+                {
+                    lastTimeElapsed = currenttime;
+                    BytesSent -= add;
+                    if (BytesSent < 0) BytesSent = 0;
+                }
+            }
+
+            public int ThrottleBytes;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
new file mode 100644
index 0000000..b01c7dc
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
@@ -0,0 +1,488 @@
+/*
+ * 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.Threading;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "GetTextureModule")]
+    public class GetTextureModule : INonSharedRegionModule
+    {
+
+        struct aPollRequest
+        {
+            public PollServiceTextureEventArgs thepoll;
+            public UUID reqID;
+            public Hashtable request;
+            public bool send503;
+        }
+
+        public class aPollResponse
+        {
+            public Hashtable response;
+            public int bytes;
+        }
+
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_scene;
+
+        private static GetTextureHandler m_getTextureHandler;
+
+        private IAssetService m_assetService = null;
+
+        private Dictionary<UUID, string> m_capsDict = new Dictionary<UUID, string>();
+        private static Thread[] m_workerThreads = null;
+        private static int m_NumberScenes = 0;
+        private static OpenSim.Framework.BlockingQueue<aPollRequest> m_queue =
+                new OpenSim.Framework.BlockingQueue<aPollRequest>();
+
+        private Dictionary<UUID,PollServiceTextureEventArgs> m_pollservices = new Dictionary<UUID,PollServiceTextureEventArgs>();
+
+        private string m_Url = "localhost";
+
+        #region ISharedRegionModule Members
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+
+            if (config == null)
+                return;
+/*
+            m_URL = config.GetString("Cap_GetTexture", string.Empty);
+            // Cap doesn't exist
+            if (m_URL != string.Empty)
+            {
+                m_Enabled = true;
+                m_RedirectURL = config.GetString("GetTextureRedirectURL");
+            }
+*/
+            m_Url = config.GetString("Cap_GetTexture", "localhost");
+        }
+
+        public void AddRegion(Scene s)
+        {
+            m_scene = s;
+            m_assetService = s.AssetService;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps -= DeregisterCaps;
+            m_scene.EventManager.OnThrottleUpdate -= ThrottleUpdate;
+            m_NumberScenes--;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            // We'll reuse the same handler for all requests.
+            m_getTextureHandler = new GetTextureHandler(m_assetService);
+
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps += DeregisterCaps;
+            m_scene.EventManager.OnThrottleUpdate += ThrottleUpdate;
+
+            m_NumberScenes++;
+
+            if (m_workerThreads == null)
+            {
+                m_workerThreads = new Thread[2];
+
+                for (uint i = 0; i < 2; i++)
+                {
+                    m_workerThreads[i] = WorkManager.StartThread(DoTextureRequests,
+                            String.Format("GetTextureWorker{0}", i),
+                            ThreadPriority.Normal,
+                            true,
+                            false,
+                            null,
+                            int.MaxValue);
+                }
+            }
+        }
+        private int ExtractImageThrottle(byte[] pthrottles)
+        {
+
+            byte[] adjData;
+            int pos = 0;
+
+            if (!BitConverter.IsLittleEndian)
+            {
+                byte[] newData = new byte[7 * 4];
+                Buffer.BlockCopy(pthrottles, 0, newData, 0, 7 * 4);
+
+                for (int i = 0; i < 7; i++)
+                    Array.Reverse(newData, i * 4, 4);
+
+                adjData = newData;
+            }
+            else
+            {
+                adjData = pthrottles;
+            }
+
+            pos = pos + 20;
+            int texture = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); //pos += 4;
+            //int asset = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f);
+            return texture;
+        }
+
+        // Now we know when the throttle is changed by the client in the case of a root agent or by a neighbor region in the case of a child agent.
+        public void ThrottleUpdate(ScenePresence p)
+        {
+            byte[] throttles = p.ControllingClient.GetThrottlesPacked(1);
+            UUID user = p.UUID;
+            int imagethrottle = ExtractImageThrottle(throttles);
+            PollServiceTextureEventArgs args;
+            if (m_pollservices.TryGetValue(user,out args))
+            {
+                args.UpdateThrottle(imagethrottle);
+            }
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+            if(m_NumberScenes <= 0 && m_workerThreads != null)
+            {
+                m_log.DebugFormat("[GetTextureModule] Closing");
+
+                foreach (Thread t in m_workerThreads)
+                    Watchdog.AbortThread(t.ManagedThreadId);
+
+                m_queue.Clear();
+            }
+        }
+
+        public string Name { get { return "GetTextureModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        private class PollServiceTextureEventArgs : PollServiceEventArgs
+        {
+            private List<Hashtable> requests =
+                    new List<Hashtable>();
+            private Dictionary<UUID, aPollResponse> responses =
+                    new Dictionary<UUID, aPollResponse>();
+
+            private Scene m_scene;
+            private CapsDataThrottler m_throttler = new CapsDataThrottler(100000);
+            public PollServiceTextureEventArgs(UUID pId, Scene scene) :
+                    base(null, "", null, null, null, pId, int.MaxValue)
+            {
+                m_scene = scene;
+                // x is request id, y is userid
+                HasEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        bool ret = m_throttler.hasEvents(x, responses);
+                        return ret;
+
+                    }
+                };
+                GetEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        try
+                        {
+                            return responses[x].response;
+                        }
+                        finally
+                        {
+                            responses.Remove(x);
+                            m_throttler.PassTime();
+                        }
+                    }
+                };
+                // x is request id, y is request data hashtable
+                Request = (x, y) =>
+                {
+                    aPollRequest reqinfo = new aPollRequest();
+                    reqinfo.thepoll = this;
+                    reqinfo.reqID = x;
+                    reqinfo.request = y;
+                    reqinfo.send503 = false;
+
+                    lock (responses)
+                    {
+                        if (responses.Count > 0)
+                        {
+                            if (m_queue.Count() >= 4)
+                            {
+                                // Never allow more than 4 fetches to wait
+                                reqinfo.send503 = true;
+                            }
+                        }
+                    }
+                    m_queue.Enqueue(reqinfo);
+                    m_throttler.PassTime();
+                };
+
+                // this should never happen except possible on shutdown
+                NoEvents = (x, y) =>
+                {
+/*
+                    lock (requests)
+                    {
+                        Hashtable request = requests.Find(id => id["RequestID"].ToString() == x.ToString());
+                        requests.Remove(request);
+                    }
+*/
+                    Hashtable response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    return response;
+                };
+            }
+
+            public void Process(aPollRequest requestinfo)
+            {
+                Hashtable response;
+
+                UUID requestID = requestinfo.reqID;
+
+                if(m_scene.ShuttingDown)
+                    return;
+
+                if (requestinfo.send503)
+                {
+                    response = new Hashtable();
+
+                    response["int_response_code"] = 503;
+                    response["str_response_string"] = "Throttled";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    Hashtable headers = new Hashtable();
+                    headers["Retry-After"] = 30;
+                    response["headers"] = headers;
+
+                    lock (responses)
+                        responses[requestID] = new aPollResponse() {bytes = 0, response = response};
+
+                    return;
+                }
+
+                // If the avatar is gone, don't bother to get the texture
+                if (m_scene.GetScenePresence(Id) == null)
+                {
+                    response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    lock (responses)
+                        responses[requestID] = new aPollResponse() {bytes = 0, response = response};
+
+                    return;
+                }
+
+                response = m_getTextureHandler.Handle(requestinfo.request);
+                lock (responses)
+                {
+                    responses[requestID] = new aPollResponse()
+                                               {
+                                                   bytes = (int) response["int_bytes"],
+                                                   response = response
+                                               };
+
+                }
+                m_throttler.PassTime();
+            }
+
+            internal void UpdateThrottle(int pimagethrottle)
+            {
+                int tmp = 2 * pimagethrottle;
+                if(tmp < 10000)
+                    tmp = 10000;
+                m_throttler.ThrottleBytes = tmp;
+            }
+        }
+
+        private void RegisterCaps(UUID agentID, Caps caps)
+        {
+            if (m_Url == "localhost")
+            {
+                string capUrl = "/CAPS/" + UUID.Random() + "/";
+
+                // Register this as a poll service
+                PollServiceTextureEventArgs args = new PollServiceTextureEventArgs(agentID, m_scene);
+
+                args.Type = PollServiceEventArgs.EventType.Texture;
+                MainServer.Instance.AddPollServiceHTTPHandler(capUrl, args);
+
+                string hostName = m_scene.RegionInfo.ExternalHostName;
+                uint port = (MainServer.Instance == null) ? 0 : MainServer.Instance.Port;
+                string protocol = "http";
+
+                if (MainServer.Instance.UseSSL)
+                {
+                    hostName = MainServer.Instance.SSLCommonName;
+                    port = MainServer.Instance.SSLPort;
+                    protocol = "https";
+                }
+                IExternalCapsModule handler = m_scene.RequestModuleInterface<IExternalCapsModule>();
+                if (handler != null)
+                    handler.RegisterExternalUserCapsHandler(agentID, caps, "GetTexture", capUrl);
+                else
+                    caps.RegisterHandler("GetTexture", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
+                m_pollservices[agentID] = args;
+                m_capsDict[agentID] = capUrl;
+            }
+            else
+            {
+                caps.RegisterHandler("GetTexture", m_Url);
+            }
+        }
+
+        private void DeregisterCaps(UUID agentID, Caps caps)
+        {
+            PollServiceTextureEventArgs args;
+
+            MainServer.Instance.RemoveHTTPHandler("", m_Url);
+            m_capsDict.Remove(agentID);
+
+            if (m_pollservices.TryGetValue(agentID, out args))
+            {
+                m_pollservices.Remove(agentID);
+            }
+        }
+
+        private static void DoTextureRequests()
+        {
+            while (true)
+            {
+                aPollRequest poolreq = m_queue.Dequeue(4500);
+                Watchdog.UpdateThread();
+                if(m_NumberScenes <= 0)
+                    return;
+                if(poolreq.reqID != UUID.Zero)
+                    poolreq.thepoll.Process(poolreq);
+            }
+        }
+
+        internal sealed class CapsDataThrottler
+        {
+            private double lastTimeElapsed = 0;
+            private volatile int BytesSent = 0;
+            public CapsDataThrottler(int pBytes)
+            {
+                if(pBytes < 10000)
+                    pBytes = 10000;
+                ThrottleBytes = pBytes;
+                lastTimeElapsed = Util.GetTimeStampMS();
+            }
+            public bool hasEvents(UUID key, Dictionary<UUID, GetTextureModule.aPollResponse> responses)
+            {
+                PassTime();
+                // Note, this is called IN LOCK
+                bool haskey = responses.ContainsKey(key);
+                if (!haskey)
+                {
+                    return false;
+                }
+                GetTextureModule.aPollResponse response;
+                if (responses.TryGetValue(key, out response))
+                {
+                    // This is any error response
+                    if (response.bytes == 0)
+                        return true;
+
+                    // Normal
+                    if (BytesSent <= ThrottleBytes)
+                    {
+                        BytesSent += response.bytes;
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+
+                return haskey;
+            }
+
+            public void PassTime()
+            {
+                double currenttime = Util.GetTimeStampMS();
+                double timeElapsed = currenttime - lastTimeElapsed;
+                if(timeElapsed < 50.0)
+                    return;
+                int add = (int)(ThrottleBytes * timeElapsed * 0.001);
+                if (add >= 1000)
+                {
+                    lastTimeElapsed = currenttime;
+                    BytesSent -= add;
+                    if (BytesSent < 0) BytesSent = 0;
+                }
+            }
+            public int ThrottleBytes;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs
new file mode 100644
index 0000000..44bf1a5
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs
@@ -0,0 +1,151 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    /// <summary>
+    /// MeshUploadFlag capability. This is required for uploading Mesh.
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "MeshUploadFlagModule")]
+    public class MeshUploadFlagModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Is this module enabled?
+        /// </summary>
+        public bool Enabled { get; private set; }
+
+        private Scene m_scene;
+
+        #region ISharedRegionModule Members
+
+        public MeshUploadFlagModule()
+        {
+            Enabled = true;
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["Mesh"];
+            if (config == null)
+            {
+                return;
+            }
+            else
+            {
+                Enabled = config.GetBoolean("AllowMeshUpload", Enabled);
+            }
+        }
+
+        public void AddRegion(Scene s)
+        {
+            if (!Enabled)
+                return;
+
+            m_scene = s;
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            if (!Enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "MeshUploadFlagModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            IRequestHandler reqHandler
+                = new RestHTTPHandler(
+                    "GET", "/CAPS/" + UUID.Random(), ht => MeshUploadFlag(ht, agentID), "MeshUploadFlag", agentID.ToString());
+
+            caps.RegisterHandler("MeshUploadFlag", reqHandler);
+
+        }
+
+        private Hashtable MeshUploadFlag(Hashtable mDhttpMethod, UUID agentID)
+        {
+//            m_log.DebugFormat("[MESH UPLOAD FLAG MODULE]: MeshUploadFlag request");
+
+            OSDMap data = new OSDMap();
+//          ScenePresence sp = m_scene.GetScenePresence(m_agentID);
+//          data["username"] = sp.Firstname + "." + sp.Lastname;
+//          data["display_name_next_update"] = new OSDDate(DateTime.Now);
+//          data["legacy_first_name"] = sp.Firstname;
+            data["mesh_upload_status"] = "valid";
+//          data["display_name"] = sp.Firstname + " " + sp.Lastname;
+//          data["legacy_last_name"] = sp.Lastname;
+//          data["id"] = m_agentID;
+//          data["is_display_name_default"] = true;
+
+            //Send back data
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 200;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = OSDParser.SerializeLLSDXmlString(data);
+            return responsedata;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
new file mode 100644
index 0000000..b044e56
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
@@ -0,0 +1,389 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Mono.Addins;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Caps=OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "ObjectAdd")]
+    public class ObjectAdd : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_scene;
+
+        #region INonSharedRegionModule Members
+
+        public void Initialise(IConfigSource pSource)
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            m_scene = scene;
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (m_scene == scene)
+            {
+                m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+                m_scene = null;
+            }
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "ObjectAddModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capuuid = UUID.Random();
+
+            //            m_log.InfoFormat("[OBJECTADD]: {0}", "/CAPS/OA/" + capuuid + "/");
+
+            caps.RegisterHandler(
+                "ObjectAdd",
+                new RestHTTPHandler(
+                    "POST",
+                    "/CAPS/OA/" + capuuid + "/",
+                    httpMethod => ProcessAdd(httpMethod, agentID, caps),
+                    "ObjectAdd",
+                    agentID.ToString())); ;
+        }
+
+        public Hashtable ProcessAdd(Hashtable request, UUID AgentId, Caps cap)
+        {
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 400; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = "Request wasn't what was expected";
+            ScenePresence avatar;
+
+            if (!m_scene.TryGetScenePresence(AgentId, out avatar))
+                return responsedata;
+
+
+            OSD r = OSDParser.DeserializeLLSDXml((string)request["requestbody"]);
+            if (r.Type != OSDType.Map) // not a proper req
+                return responsedata;
+
+            //UUID session_id = UUID.Zero;
+            bool bypass_raycast = false;
+            uint everyone_mask = 0;
+            uint group_mask = 0;
+            uint next_owner_mask = 0;
+            uint flags = 0;
+            UUID group_id = UUID.Zero;
+            int hollow = 0;
+            int material = 0;
+            int p_code = 0;
+            int path_begin = 0;
+            int path_curve = 0;
+            int path_end = 0;
+            int path_radius_offset = 0;
+            int path_revolutions = 0;
+            int path_scale_x = 0;
+            int path_scale_y = 0;
+            int path_shear_x = 0;
+            int path_shear_y = 0;
+            int path_skew = 0;
+            int path_taper_x = 0;
+            int path_taper_y = 0;
+            int path_twist = 0;
+            int path_twist_begin = 0;
+            int profile_begin = 0;
+            int profile_curve = 0;
+            int profile_end = 0;
+            Vector3 ray_end = Vector3.Zero;
+            bool ray_end_is_intersection = false;
+            Vector3 ray_start = Vector3.Zero;
+            UUID ray_target_id = UUID.Zero;
+            Quaternion rotation = Quaternion.Identity;
+            Vector3 scale = Vector3.Zero;
+            int state = 0;
+            int lastattach = 0;
+
+            OSDMap rm = (OSDMap)r;
+
+            if (rm.ContainsKey("ObjectData")) //v2
+            {
+                if (rm["ObjectData"].Type != OSDType.Map)
+                {
+                    responsedata["str_response_string"] = "Has ObjectData key, but data not in expected format";
+                    return responsedata;
+                }
+
+                OSDMap ObjMap = (OSDMap)rm["ObjectData"];
+
+                bypass_raycast = ObjMap["BypassRaycast"].AsBoolean();
+                everyone_mask = readuintval(ObjMap["EveryoneMask"]);
+                flags = readuintval(ObjMap["Flags"]);
+                group_mask = readuintval(ObjMap["GroupMask"]);
+                material = ObjMap["Material"].AsInteger();
+                next_owner_mask = readuintval(ObjMap["NextOwnerMask"]);
+                p_code = ObjMap["PCode"].AsInteger();
+
+                if (ObjMap.ContainsKey("Path"))
+                {
+                    if (ObjMap["Path"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has Path key, but data not in expected format";
+                        return responsedata;
+                    }
+
+                    OSDMap PathMap = (OSDMap)ObjMap["Path"];
+                    path_begin = PathMap["Begin"].AsInteger();
+                    path_curve = PathMap["Curve"].AsInteger();
+                    path_end = PathMap["End"].AsInteger();
+                    path_radius_offset = PathMap["RadiusOffset"].AsInteger();
+                    path_revolutions = PathMap["Revolutions"].AsInteger();
+                    path_scale_x = PathMap["ScaleX"].AsInteger();
+                    path_scale_y = PathMap["ScaleY"].AsInteger();
+                    path_shear_x = PathMap["ShearX"].AsInteger();
+                    path_shear_y = PathMap["ShearY"].AsInteger();
+                    path_skew = PathMap["Skew"].AsInteger();
+                    path_taper_x = PathMap["TaperX"].AsInteger();
+                    path_taper_y = PathMap["TaperY"].AsInteger();
+                    path_twist = PathMap["Twist"].AsInteger();
+                    path_twist_begin = PathMap["TwistBegin"].AsInteger();
+
+                }
+
+                if (ObjMap.ContainsKey("Profile"))
+                {
+                    if (ObjMap["Profile"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has Profile key, but data not in expected format";
+                        return responsedata;
+                    }
+
+                    OSDMap ProfileMap = (OSDMap)ObjMap["Profile"];
+
+                    profile_begin = ProfileMap["Begin"].AsInteger();
+                    profile_curve = ProfileMap["Curve"].AsInteger();
+                    profile_end = ProfileMap["End"].AsInteger();
+                    hollow = ProfileMap["Hollow"].AsInteger();
+                }
+                ray_end_is_intersection = ObjMap["RayEndIsIntersection"].AsBoolean();
+
+                ray_target_id = ObjMap["RayTargetId"].AsUUID();
+                state = ObjMap["State"].AsInteger();
+                lastattach = ObjMap["LastAttachPoint"].AsInteger();
+                try
+                {
+                    ray_end = ((OSDArray)ObjMap["RayEnd"]).AsVector3();
+                    ray_start = ((OSDArray)ObjMap["RayStart"]).AsVector3();
+                    scale = ((OSDArray)ObjMap["Scale"]).AsVector3();
+                    rotation = ((OSDArray)ObjMap["Rotation"]).AsQuaternion();
+                }
+                catch (Exception)
+                {
+                    responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format";
+                    return responsedata;
+                }
+
+                if (rm.ContainsKey("AgentData"))
+                {
+                    if (rm["AgentData"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has AgentData key, but data not in expected format";
+                        return responsedata;
+                    }
+
+                    OSDMap AgentDataMap = (OSDMap)rm["AgentData"];
+
+                    //session_id = AgentDataMap["SessionId"].AsUUID();
+                    group_id = AgentDataMap["GroupId"].AsUUID();
+                }
+
+            }
+            else
+            { //v1
+                bypass_raycast = rm["bypass_raycast"].AsBoolean();
+
+                everyone_mask = readuintval(rm["everyone_mask"]);
+                flags = readuintval(rm["flags"]);
+                group_id = rm["group_id"].AsUUID();
+                group_mask = readuintval(rm["group_mask"]);
+                hollow = rm["hollow"].AsInteger();
+                material = rm["material"].AsInteger();
+                next_owner_mask = readuintval(rm["next_owner_mask"]);
+                hollow = rm["hollow"].AsInteger();
+                p_code = rm["p_code"].AsInteger();
+                path_begin = rm["path_begin"].AsInteger();
+                path_curve = rm["path_curve"].AsInteger();
+                path_end = rm["path_end"].AsInteger();
+                path_radius_offset = rm["path_radius_offset"].AsInteger();
+                path_revolutions = rm["path_revolutions"].AsInteger();
+                path_scale_x = rm["path_scale_x"].AsInteger();
+                path_scale_y = rm["path_scale_y"].AsInteger();
+                path_shear_x = rm["path_shear_x"].AsInteger();
+                path_shear_y = rm["path_shear_y"].AsInteger();
+                path_skew = rm["path_skew"].AsInteger();
+                path_taper_x = rm["path_taper_x"].AsInteger();
+                path_taper_y = rm["path_taper_y"].AsInteger();
+                path_twist = rm["path_twist"].AsInteger();
+                path_twist_begin = rm["path_twist_begin"].AsInteger();
+                profile_begin = rm["profile_begin"].AsInteger();
+                profile_curve = rm["profile_curve"].AsInteger();
+                profile_end = rm["profile_end"].AsInteger();
+
+                ray_end_is_intersection = rm["ray_end_is_intersection"].AsBoolean();
+
+                ray_target_id = rm["ray_target_id"].AsUUID();
+
+
+                //session_id = rm["session_id"].AsUUID();
+                state = rm["state"].AsInteger();
+                lastattach = rm["last_attach_point"].AsInteger();
+                try
+                {
+                    ray_end = ((OSDArray)rm["ray_end"]).AsVector3();
+                    ray_start = ((OSDArray)rm["ray_start"]).AsVector3();
+                    rotation = ((OSDArray)rm["rotation"]).AsQuaternion();
+                    scale = ((OSDArray)rm["scale"]).AsVector3();
+                }
+                catch (Exception)
+                {
+                    responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format";
+                    return responsedata;
+                }
+            }
+
+            Vector3 pos = m_scene.GetNewRezLocation(ray_start, ray_end, ray_target_id, rotation, (bypass_raycast) ? (byte)1 : (byte)0, (ray_end_is_intersection) ? (byte)1 : (byte)0, true, scale, false);
+
+            PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+
+            pbs.PathBegin = (ushort)path_begin;
+            pbs.PathCurve = (byte)path_curve;
+            pbs.PathEnd = (ushort)path_end;
+            pbs.PathRadiusOffset = (sbyte)path_radius_offset;
+            pbs.PathRevolutions = (byte)path_revolutions;
+            pbs.PathScaleX = (byte)path_scale_x;
+            pbs.PathScaleY = (byte)path_scale_y;
+            pbs.PathShearX = (byte)path_shear_x;
+            pbs.PathShearY = (byte)path_shear_y;
+            pbs.PathSkew = (sbyte)path_skew;
+            pbs.PathTaperX = (sbyte)path_taper_x;
+            pbs.PathTaperY = (sbyte)path_taper_y;
+            pbs.PathTwist = (sbyte)path_twist;
+            pbs.PathTwistBegin = (sbyte)path_twist_begin;
+            pbs.HollowShape = (HollowShape)hollow;
+            pbs.PCode = (byte)p_code;
+            pbs.ProfileBegin = (ushort)profile_begin;
+            pbs.ProfileCurve = (byte)profile_curve;
+            pbs.ProfileEnd = (ushort)profile_end;
+            pbs.Scale = scale;
+            pbs.State = (byte)state;
+            pbs.LastAttachPoint = (byte)lastattach;
+
+            SceneObjectGroup obj = null; ;
+
+            if (m_scene.Permissions.CanRezObject(1, avatar.UUID, pos))
+            {
+                // rez ON the ground, not IN the ground
+                // pos.Z += 0.25F;
+
+                obj = m_scene.AddNewPrim(avatar.UUID, group_id, pos, rotation, pbs);
+            }
+
+
+            if (obj == null)
+                return responsedata;
+
+            SceneObjectPart rootpart = obj.RootPart;
+            rootpart.Shape = pbs;
+            rootpart.Flags |= (PrimFlags)flags;
+            rootpart.EveryoneMask = everyone_mask;
+            rootpart.GroupID = group_id;
+            rootpart.GroupMask = group_mask;
+            rootpart.NextOwnerMask = next_owner_mask;
+            rootpart.Material = (byte)material;
+
+            obj.InvalidateDeepEffectivePerms();
+
+            m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
+
+            responsedata["int_response_code"] = 200; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = String.Format("<llsd><map><key>local_id</key>{0}</map></llsd>", ConvertUintToBytes(obj.LocalId));
+
+            return responsedata;
+        }
+
+        private uint readuintval(OSD obj)
+        {
+            byte[] tmp = obj.AsBinary();
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(tmp);
+            return Utils.BytesToUInt(tmp);
+
+        }
+        private string ConvertUintToBytes(uint val)
+        {
+            byte[] resultbytes = Utils.UIntToBytes(val);
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(resultbytes);
+            return String.Format("<binary encoding=\"base64\">{0}</binary>", Convert.ToBase64String(resultbytes));
+        }
+
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs
new file mode 100644
index 0000000..116c51f
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs
@@ -0,0 +1,380 @@
+/*
+ * 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.Specialized;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using Mono.Addins;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Messages.Linden;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OSD = OpenMetaverse.StructuredData.OSD;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+using OpenSim.Framework.Capabilities;
+using ExtraParamType = OpenMetaverse.ExtraParamType;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "UploadObjectAssetModule")]
+    public class UploadObjectAssetModule : INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private Scene m_scene;
+
+        #region Region Module interfaceBase Members
+
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+
+        }
+
+        public void AddRegion(Scene pScene)
+        {
+            m_scene = pScene;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        #endregion
+
+
+        #region Region Module interface
+
+
+
+        public void Close() { }
+
+        public string Name { get { return "UploadObjectAssetModuleModule"; } }
+
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capID = UUID.Random();
+
+//            m_log.Debug("[UPLOAD OBJECT ASSET MODULE]: /CAPS/" + capID);
+            caps.RegisterHandler(
+                "UploadObjectAsset",
+                new RestHTTPHandler(
+                    "POST",
+                    "/CAPS/OA/" + capID + "/",
+                    httpMethod => ProcessAdd(httpMethod, agentID, caps),
+                    "UploadObjectAsset",
+                    agentID.ToString()));
+
+            /*
+                   caps.RegisterHandler("NewFileAgentInventoryVariablePrice",
+
+                           new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDNewFileAngentInventoryVariablePriceReplyResponse>("POST",
+                                                                                                  "/CAPS/" + capID.ToString(),
+                                                                                                  delegate(LLSDAssetUploadRequest req)
+                                                              {
+                                                                  return NewAgentInventoryRequest(req,agentID);
+                                                              }));
+             */
+
+        }
+
+        #endregion
+
+
+        /// <summary>
+        /// Parses add request
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="AgentId"></param>
+        /// <param name="cap"></param>
+        /// <returns></returns>
+        public Hashtable ProcessAdd(Hashtable request, UUID AgentId, Caps cap)
+        {
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 400; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = "Request wasn't what was expected";
+            ScenePresence avatar;
+
+            if (!m_scene.TryGetScenePresence(AgentId, out avatar))
+                return responsedata;
+
+            OSDMap r = (OSDMap)OSDParser.Deserialize((string)request["requestbody"]);
+            UploadObjectAssetMessage message = new UploadObjectAssetMessage();
+            try
+            {
+                message.Deserialize(r);
+
+            }
+            catch (Exception ex)
+            {
+                m_log.Error("[UPLOAD OBJECT ASSET MODULE]: Error deserializing message " + ex.ToString());
+                message = null;
+            }
+
+            if (message == null)
+            {
+                responsedata["int_response_code"] = 400; //501; //410; //404;
+                responsedata["content_type"] = "text/plain";
+                responsedata["keepalive"] = false;
+                responsedata["str_response_string"] =
+                    "<llsd><map><key>error</key><string>Error parsing Object</string></map></llsd>";
+
+                return responsedata;
+            }
+
+            Vector3 pos = avatar.AbsolutePosition + (Vector3.UnitX * avatar.Rotation);
+            Quaternion rot = Quaternion.Identity;
+            Vector3 rootpos = Vector3.Zero;
+//            Quaternion rootrot = Quaternion.Identity;
+
+            SceneObjectGroup rootGroup = null;
+            SceneObjectGroup[] allparts = new SceneObjectGroup[message.Objects.Length];
+            for (int i = 0; i < message.Objects.Length; i++)
+            {
+                UploadObjectAssetMessage.Object obj = message.Objects[i];
+                PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+
+                if (i == 0)
+                {
+                    rootpos = obj.Position;
+//                    rootrot = obj.Rotation;
+                }
+
+                // Combine the extraparams data into it's ugly blob again....
+                //int bytelength = 0;
+                //for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++)
+                //{
+                //    bytelength += obj.ExtraParams[extparams].ExtraParamData.Length;
+                //}
+                //byte[] extraparams = new byte[bytelength];
+                //int position = 0;
+
+
+
+                //for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++)
+                //{
+                //    Buffer.BlockCopy(obj.ExtraParams[extparams].ExtraParamData, 0, extraparams, position,
+                //                     obj.ExtraParams[extparams].ExtraParamData.Length);
+                //
+                //    position += obj.ExtraParams[extparams].ExtraParamData.Length;
+               // }
+
+                //pbs.ExtraParams = extraparams;
+                for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++)
+                {
+                    UploadObjectAssetMessage.Object.ExtraParam extraParam = obj.ExtraParams[extparams];
+                    switch ((ushort)extraParam.Type)
+                    {
+                        case (ushort)ExtraParamType.Sculpt:
+                            Primitive.SculptData sculpt = new Primitive.SculptData(extraParam.ExtraParamData, 0);
+
+                            pbs.SculptEntry = true;
+
+                            pbs.SculptTexture = obj.SculptID;
+                            pbs.SculptType = (byte)sculpt.Type;
+
+                            break;
+                        case (ushort)ExtraParamType.Flexible:
+                            Primitive.FlexibleData flex = new Primitive.FlexibleData(extraParam.ExtraParamData, 0);
+                            pbs.FlexiEntry = true;
+                            pbs.FlexiDrag = flex.Drag;
+                            pbs.FlexiForceX = flex.Force.X;
+                            pbs.FlexiForceY = flex.Force.Y;
+                            pbs.FlexiForceZ = flex.Force.Z;
+                            pbs.FlexiGravity = flex.Gravity;
+                            pbs.FlexiSoftness = flex.Softness;
+                            pbs.FlexiTension = flex.Tension;
+                            pbs.FlexiWind = flex.Wind;
+                            break;
+                        case (ushort)ExtraParamType.Light:
+                            Primitive.LightData light = new Primitive.LightData(extraParam.ExtraParamData, 0);
+                            pbs.LightColorA = light.Color.A;
+                            pbs.LightColorB = light.Color.B;
+                            pbs.LightColorG = light.Color.G;
+                            pbs.LightColorR = light.Color.R;
+                            pbs.LightCutoff = light.Cutoff;
+                            pbs.LightEntry = true;
+                            pbs.LightFalloff = light.Falloff;
+                            pbs.LightIntensity = light.Intensity;
+                            pbs.LightRadius = light.Radius;
+                            break;
+                        case 0x40:
+                            pbs.ReadProjectionData(extraParam.ExtraParamData, 0);
+                            break;
+                    }
+                }
+
+                pbs.PathBegin = (ushort) obj.PathBegin;
+                pbs.PathCurve = (byte) obj.PathCurve;
+                pbs.PathEnd = (ushort) obj.PathEnd;
+                pbs.PathRadiusOffset = (sbyte) obj.RadiusOffset;
+                pbs.PathRevolutions = (byte) obj.Revolutions;
+                pbs.PathScaleX = (byte) obj.ScaleX;
+                pbs.PathScaleY = (byte) obj.ScaleY;
+                pbs.PathShearX = (byte) obj.ShearX;
+                pbs.PathShearY = (byte) obj.ShearY;
+                pbs.PathSkew = (sbyte) obj.Skew;
+                pbs.PathTaperX = (sbyte) obj.TaperX;
+                pbs.PathTaperY = (sbyte) obj.TaperY;
+                pbs.PathTwist = (sbyte) obj.Twist;
+                pbs.PathTwistBegin = (sbyte) obj.TwistBegin;
+                pbs.HollowShape = (HollowShape) obj.ProfileHollow;
+                pbs.PCode = (byte) PCode.Prim;
+                pbs.ProfileBegin = (ushort) obj.ProfileBegin;
+                pbs.ProfileCurve = (byte) obj.ProfileCurve;
+                pbs.ProfileEnd = (ushort) obj.ProfileEnd;
+                pbs.Scale = obj.Scale;
+                pbs.State = (byte) 0;
+                pbs.LastAttachPoint = (byte) 0;
+                SceneObjectPart prim = new SceneObjectPart();
+                prim.UUID = UUID.Random();
+                prim.CreatorID = AgentId;
+                prim.OwnerID = AgentId;
+                prim.GroupID = obj.GroupID;
+                prim.LastOwnerID = prim.OwnerID;
+                prim.RezzerID = AgentId;
+                prim.CreationDate = Util.UnixTimeSinceEpoch();
+                prim.Name = obj.Name;
+                prim.Description = "";
+
+                prim.PayPrice[0] = -2;
+                prim.PayPrice[1] = -2;
+                prim.PayPrice[2] = -2;
+                prim.PayPrice[3] = -2;
+                prim.PayPrice[4] = -2;
+                Primitive.TextureEntry tmp =
+                    new Primitive.TextureEntry(UUID.Parse("89556747-24cb-43ed-920b-47caed15465f"));
+
+                for (int j = 0; j < obj.Faces.Length; j++)
+                {
+                    UploadObjectAssetMessage.Object.Face face = obj.Faces[j];
+
+                    Primitive.TextureEntryFace primFace = tmp.CreateFace((uint) j);
+
+                    primFace.Bump = face.Bump;
+                    primFace.RGBA = face.Color;
+                    primFace.Fullbright = face.Fullbright;
+                    primFace.Glow = face.Glow;
+                    primFace.TextureID = face.ImageID;
+                    primFace.Rotation = face.ImageRot;
+                    primFace.MediaFlags = ((face.MediaFlags & 1) != 0);
+
+                    primFace.OffsetU = face.OffsetS;
+                    primFace.OffsetV = face.OffsetT;
+                    primFace.RepeatU = face.ScaleS;
+                    primFace.RepeatV = face.ScaleT;
+                    primFace.TexMapType = (MappingType) (face.MediaFlags & 6);
+                }
+
+                pbs.TextureEntry = tmp.GetBytes();
+                prim.Shape = pbs;
+                prim.Scale = obj.Scale;
+
+                SceneObjectGroup grp = new SceneObjectGroup();
+
+                grp.SetRootPart(prim);
+                prim.ParentID = 0;
+                if (i == 0)
+                {
+                    rootGroup = grp;
+
+                }
+                grp.AttachToScene(m_scene);
+                grp.AbsolutePosition = obj.Position;
+                prim.RotationOffset = obj.Rotation;
+
+
+                // Required for linking
+                grp.RootPart.ClearUpdateSchedule();
+
+                if (m_scene.Permissions.CanRezObject(1, avatar.UUID, pos))
+                {
+                    m_scene.AddSceneObject(grp);
+                    grp.AbsolutePosition = obj.Position;
+                }
+
+                allparts[i] = grp;
+            }
+
+            for (int j = 1; j < allparts.Length; j++)
+            {
+                // Required for linking
+                rootGroup.RootPart.ClearUpdateSchedule();
+                allparts[j].RootPart.ClearUpdateSchedule();
+                rootGroup.LinkToGroup(allparts[j]);
+            }
+
+            rootGroup.ScheduleGroupForFullUpdate();
+            pos
+                = m_scene.GetNewRezLocation(
+                    Vector3.Zero, rootpos, UUID.Zero, rot, (byte)1, 1, true, allparts[0].GroupScale, false);
+
+            responsedata["int_response_code"] = 200; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = String.Format("<llsd><map><key>local_id</key>{0}</map></llsd>", ConvertUintToBytes(allparts[0].LocalId));
+
+            return responsedata;
+        }
+
+        private string ConvertUintToBytes(uint val)
+        {
+            byte[] resultbytes = Utils.UIntToBytes(val);
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(resultbytes);
+            return String.Format("<binary encoding=\"base64\">{0}</binary>", Convert.ToBase64String(resultbytes));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/Properties/AssemblyInfo.cs b/OpenSim/Region/ClientStack/Linden/Caps/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..f36826b
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Region.ClientStack.LindenCaps")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("1ae76353-f37f-4fe3-b6df-d11cedf01f2c")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion(OpenSim.VersionInfo.AssemblyVersionNumber)]
+
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs
new file mode 100644
index 0000000..e8387e3
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs
@@ -0,0 +1,242 @@
+/*
+ * 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.Collections.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "RegionConsoleModule")]
+    public class RegionConsoleModule : INonSharedRegionModule, IRegionConsole
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_scene;
+        private IEventQueue m_eventQueue;
+        private Commands m_commands = new Commands();
+        public ICommands Commands { get { return m_commands; } }
+
+        public event ConsoleMessage OnConsoleMessage;
+
+        public void Initialise(IConfigSource source)
+        {
+            m_commands.AddCommand( "Help", false, "help", "help [<item>]", "Display help on a particular command or on a list of commands in a category", Help);
+        }
+
+        public void AddRegion(Scene s)
+        {
+            m_scene = s;
+            m_scene.RegisterModuleInterface<IRegionConsole>(this);
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+            m_eventQueue = m_scene.RequestModuleInterface<IEventQueue>();
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "RegionConsoleModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            if (!m_scene.RegionInfo.EstateSettings.IsEstateManagerOrOwner(agentID) && !m_scene.Permissions.IsGod(agentID))
+                return;
+
+            UUID capID = UUID.Random();
+
+//            m_log.DebugFormat("[REGION CONSOLE]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
+            caps.RegisterHandler(
+                    "SimConsoleAsync",
+                    new ConsoleHandler("/CAPS/" + capID + "/", "SimConsoleAsync", agentID, this, m_scene));
+        }
+
+        public void SendConsoleOutput(UUID agentID, string message)
+        {
+            OSD osd = OSD.FromString(message);
+
+            m_eventQueue.Enqueue(EventQueueHelper.BuildEvent("SimConsoleResponse", osd), agentID);
+
+            ConsoleMessage handlerConsoleMessage = OnConsoleMessage;
+
+            if (handlerConsoleMessage != null)
+                handlerConsoleMessage( agentID, message);
+        }
+
+        public bool RunCommand(string command, UUID invokerID)
+        {
+            string[] parts = Parser.Parse(command);
+            Array.Resize(ref parts, parts.Length + 1);
+            parts[parts.Length - 1] = invokerID.ToString();
+
+            if (m_commands.Resolve(parts).Length == 0)
+                return false;
+
+            return true;
+        }
+
+        private void Help(string module, string[] cmd)
+        {
+            UUID agentID = new UUID(cmd[cmd.Length - 1]);
+            Array.Resize(ref cmd, cmd.Length - 1);
+
+            List<string> help = Commands.GetHelp(cmd);
+
+            string reply = String.Empty;
+
+            foreach (string s in help)
+            {
+                reply += s + "\n";
+            }
+
+            SendConsoleOutput(agentID, reply);
+        }
+
+        public void AddCommand(string module, bool shared, string command, string help, string longhelp, CommandDelegate fn)
+        {
+            m_commands.AddCommand(module, shared, command, help, longhelp, fn);
+        }
+    }
+
+    public class ConsoleHandler : BaseStreamHandler
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private RegionConsoleModule m_consoleModule;
+        private UUID m_agentID;
+        private bool m_isGod;
+        private Scene m_scene;
+        private bool m_consoleIsOn = false;
+
+        public ConsoleHandler(string path, string name, UUID agentID, RegionConsoleModule module, Scene scene)
+                :base("POST", path, name, agentID.ToString())
+        {
+            m_agentID = agentID;
+            m_consoleModule = module;
+            m_scene = scene;
+
+            m_isGod = m_scene.Permissions.IsGod(agentID);
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            string message;
+            using(StreamReader reader = new StreamReader(request))
+                message = reader.ReadToEnd();
+
+            OSD osd = OSDParser.DeserializeLLSDXml(message);
+
+            string cmd = osd.AsString();
+            if (cmd == "set console on")
+            {
+                if (m_isGod)
+                {
+                    MainConsole.Instance.OnOutput += ConsoleSender;
+                    m_consoleIsOn = true;
+                    m_consoleModule.SendConsoleOutput(m_agentID, "Console is now on");
+                }
+                return new byte[0];
+            }
+            else if (cmd == "set console off")
+            {
+                MainConsole.Instance.OnOutput -= ConsoleSender;
+                m_consoleIsOn = false;
+                m_consoleModule.SendConsoleOutput(m_agentID, "Console is now off");
+                return new byte[0];
+            }
+
+            if (m_consoleIsOn == false && m_consoleModule.RunCommand(osd.AsString().Trim(), m_agentID))
+                return new byte[0];
+
+            if (m_isGod && m_consoleIsOn)
+            {
+                MainConsole.Instance.RunCommand(osd.AsString().Trim());
+            }
+            else
+            {
+                m_consoleModule.SendConsoleOutput(m_agentID, "Unknown command");
+            }
+
+            return new byte[0];
+        }
+
+        private void ConsoleSender(string text)
+        {
+            m_consoleModule.SendConsoleOutput(m_agentID, text);
+        }
+
+        private void OnMakeChildAgent(ScenePresence presence)
+        {
+            if (presence.UUID == m_agentID)
+            {
+                MainConsole.Instance.OnOutput -= ConsoleSender;
+                m_consoleIsOn = false;
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
new file mode 100644
index 0000000..39f5baf
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
@@ -0,0 +1,304 @@
+/*
+ * 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 log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+// using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    /// <summary>
+    /// SimulatorFeatures capability.
+    /// </summary>
+    /// <remarks>
+    /// This is required for uploading Mesh.
+    /// Since is accepts an open-ended response, we also send more information
+    /// for viewers that care to interpret it.
+    ///
+    /// NOTE: Part of this code was adapted from the Aurora project, specifically
+    /// the normal part of the response in the capability handler.
+    /// </remarks>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimulatorFeaturesModule")]
+    public class SimulatorFeaturesModule : INonSharedRegionModule, ISimulatorFeaturesModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public event SimulatorFeaturesRequestDelegate OnSimulatorFeaturesRequest;
+
+        private Scene m_scene;
+
+        /// <summary>
+        /// Simulator features
+        /// </summary>
+        private OSDMap m_features = new OSDMap();
+
+        private string m_SearchURL = string.Empty;
+        private string m_DestinationGuideURL = string.Empty;
+        private bool m_ExportSupported = false;
+        private string m_GridName = string.Empty;
+        private string m_GridURL = string.Empty;
+
+        #region ISharedRegionModule Members
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["SimulatorFeatures"];
+
+            if (config != null)
+            {
+                //
+                // All this is obsolete since getting these features from the grid service!!
+                // Will be removed after the next release
+                //
+                m_SearchURL = config.GetString("SearchServerURI", m_SearchURL);
+
+                m_DestinationGuideURL = config.GetString ("DestinationGuideURI", m_DestinationGuideURL);
+
+                if (m_DestinationGuideURL == string.Empty) // Make this consistent with the variable in the LoginService config
+                    m_DestinationGuideURL = config.GetString("DestinationGuide", m_DestinationGuideURL);
+
+                m_ExportSupported = config.GetBoolean("ExportSupported", m_ExportSupported);
+
+                m_GridURL = Util.GetConfigVarFromSections<string>(
+                    source, "GatekeeperURI", new string[] { "Startup", "Hypergrid", "SimulatorFeatures" }, String.Empty);
+
+                m_GridName = config.GetString("GridName", string.Empty);
+                if (m_GridName == string.Empty)
+                    m_GridName = Util.GetConfigVarFromSections<string>(
+                        source, "gridname", new string[] { "GridInfo", "SimulatorFeatures" }, String.Empty);
+            }
+
+            AddDefaultFeatures();
+        }
+
+        public void AddRegion(Scene s)
+        {
+            m_scene = s;
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+
+            m_scene.RegisterModuleInterface<ISimulatorFeaturesModule>(this);
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            GetGridExtraFeatures(s);
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "SimulatorFeaturesModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Add default features
+        /// </summary>
+        /// <remarks>
+        /// TODO: These should be added from other modules rather than hardcoded.
+        /// </remarks>
+        private void AddDefaultFeatures()
+        {
+
+            lock (m_features)
+            {
+                m_features["MeshRezEnabled"] = true;
+                m_features["MeshUploadEnabled"] = true;
+                m_features["MeshXferEnabled"] = true;
+
+                m_features["PhysicsMaterialsEnabled"] = true;
+
+                OSDMap typesMap = new OSDMap();
+                typesMap["convex"] = true;
+                typesMap["none"] = true;
+                typesMap["prim"] = true;
+                m_features["PhysicsShapeTypes"] = typesMap;
+
+                // Extra information for viewers that want to use it
+                // TODO: Take these out of here into their respective modules, like map-server-url
+                OSDMap extrasMap;
+                if(m_features.ContainsKey("OpenSimExtras"))
+                {
+                    extrasMap = (OSDMap)m_features["OpenSimExtras"];
+                }
+                else
+                    extrasMap = new OSDMap();
+
+                extrasMap["AvatarSkeleton"] = true;
+                extrasMap["AnimationSet"] = true;
+
+                // TODO: Take these out of here into their respective modules, like map-server-url
+                if (m_SearchURL != string.Empty)
+                    extrasMap["search-server-url"] = m_SearchURL;
+                if (!string.IsNullOrEmpty(m_DestinationGuideURL))
+                    extrasMap["destination-guide-url"] = m_DestinationGuideURL;
+                if (m_ExportSupported)
+                    extrasMap["ExportSupported"] = true;
+                if (m_GridURL != string.Empty)
+                    extrasMap["GridURL"] = m_GridURL;
+                if (m_GridName != string.Empty)
+                    extrasMap["GridName"] = m_GridName;
+
+                if (extrasMap.Count > 0)
+                    m_features["OpenSimExtras"] = extrasMap;
+            }
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            IRequestHandler reqHandler
+                = new RestHTTPHandler(
+                    "GET", "/CAPS/" + UUID.Random(),
+                    x => { return HandleSimulatorFeaturesRequest(x, agentID); }, "SimulatorFeatures", agentID.ToString());
+
+            caps.RegisterHandler("SimulatorFeatures", reqHandler);
+        }
+
+        public void AddFeature(string name, OSD value)
+        {
+            lock (m_features)
+                m_features[name] = value;
+        }
+
+        public bool RemoveFeature(string name)
+        {
+            lock (m_features)
+                return m_features.Remove(name);
+        }
+
+        public bool TryGetFeature(string name, out OSD value)
+        {
+            lock (m_features)
+                return m_features.TryGetValue(name, out value);
+        }
+
+        public OSDMap GetFeatures()
+        {
+            lock (m_features)
+                return new OSDMap(m_features);
+        }
+
+        private OSDMap DeepCopy()
+        {
+            // This isn't the cheapest way of doing this but the rate
+            // of occurrence is low (on sim entry only) and it's a sure
+            // way to get a true deep copy.
+            OSD copy = OSDParser.DeserializeLLSDXml(OSDParser.SerializeLLSDXmlString(m_features));
+
+            return (OSDMap)copy;
+        }
+
+        private Hashtable HandleSimulatorFeaturesRequest(Hashtable mDhttpMethod, UUID agentID)
+        {
+//            m_log.DebugFormat("[SIMULATOR FEATURES MODULE]: SimulatorFeatures request");
+
+            OSDMap copy = DeepCopy();
+
+            // Let's add the agentID to the destination guide, if it is expecting that.
+            if (copy.ContainsKey("OpenSimExtras") && ((OSDMap)(copy["OpenSimExtras"])).ContainsKey("destination-guide-url"))
+                ((OSDMap)copy["OpenSimExtras"])["destination-guide-url"] = Replace(((OSDMap)copy["OpenSimExtras"])["destination-guide-url"], "[USERID]", agentID.ToString());
+
+            SimulatorFeaturesRequestDelegate handlerOnSimulatorFeaturesRequest = OnSimulatorFeaturesRequest;
+
+            if (handlerOnSimulatorFeaturesRequest != null)
+                handlerOnSimulatorFeaturesRequest(agentID, ref copy);
+
+            //Send back data
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 200;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+
+            responsedata["str_response_string"] = OSDParser.SerializeLLSDXmlString(copy);
+
+            return responsedata;
+        }
+
+        /// <summary>
+        /// Gets the grid extra features.
+        /// </summary>
+        /// <param name='featuresURI'>
+        /// The URI Robust uses to handle the get_extra_features request
+        /// </param>
+        private void GetGridExtraFeatures(Scene scene)
+        {
+            Dictionary<string, object> extraFeatures = scene.GridService.GetExtraFeatures();
+            if (extraFeatures.ContainsKey("Result") && extraFeatures["Result"] != null && extraFeatures["Result"].ToString() == "Failure")
+            {
+                m_log.WarnFormat("[SIMULATOR FEATURES MODULE]: Unable to retrieve grid-wide features");
+                return;
+            }
+
+            lock (m_features)
+            {
+                OSDMap extrasMap = new OSDMap();
+
+                foreach(string key in extraFeatures.Keys)
+                {
+                    extrasMap[key] = (string)extraFeatures[key];
+
+                    if (key == "ExportSupported")
+                    {
+                        bool.TryParse(extraFeatures[key].ToString(), out m_ExportSupported);
+                    }
+                }
+                m_features["OpenSimExtras"] = extrasMap;
+
+            }
+        }
+
+        private string Replace(string url, string substring, string replacement)
+        {
+            if (!String.IsNullOrEmpty(url) && url.Contains(substring))
+                return url.Replace(substring, replacement);
+
+            return url;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/Tests/WebFetchInvDescModuleTests.cs b/OpenSim/Region/ClientStack/Linden/Caps/Tests/WebFetchInvDescModuleTests.cs
new file mode 100644
index 0000000..6ffed4d
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/Tests/WebFetchInvDescModuleTests.cs
@@ -0,0 +1,161 @@
+/*
+ * 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;
+using System.Text;
+using HttpServer;
+using log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.ClientStack.Linden;
+using OpenSim.Region.CoreModules.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenSim.Tests.Common;
+using OSDArray = OpenMetaverse.StructuredData.OSDArray;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+
+namespace OpenSim.Region.ClientStack.Linden.Caps.Tests
+{
+    /*
+    [TestFixture]
+    public class WebFetchInvDescModuleTests : OpenSimTestCase
+    {
+        [TestFixtureSetUp]
+        public void TestFixtureSetUp()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
+        }
+
+        [TestFixtureTearDown]
+        public void TestFixureTearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten so none of them require async stuff (which regression
+            // tests really shouldn't).
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
+
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            // This is an unfortunate bit of clean up we have to do because MainServer manages things through static
+            // variables and the VM is not restarted between tests.
+            uint port = 9999;
+            MainServer.RemoveHttpServer(port);
+
+            BaseHttpServer server = new BaseHttpServer(port, false, 0, "");
+            MainServer.AddHttpServer(server);
+            MainServer.Instance = server;
+
+            server.Start(false);
+        }
+
+        [Test]
+        public void TestInventoryDescendentsFetch()
+        {
+            TestHelpers.InMethod();
+            TestHelpers.EnableLogging();
+
+            BaseHttpServer httpServer = MainServer.Instance;
+            Scene scene = new SceneHelpers().SetupScene();
+
+            CapabilitiesModule capsModule = new CapabilitiesModule();
+            WebFetchInvDescModule wfidModule = new WebFetchInvDescModule(false);
+
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("ClientStack.LindenCaps");
+            config.Configs["ClientStack.LindenCaps"].Set("Cap_FetchInventoryDescendents2", "localhost");
+
+            SceneHelpers.SetupSceneModules(scene, config, capsModule, wfidModule);
+
+            UserAccount ua = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(0x1));
+
+            // We need a user present to have any capabilities set up
+            SceneHelpers.AddScenePresence(scene, ua.PrincipalID);
+
+            TestHttpRequest req = new TestHttpRequest();
+            OpenSim.Framework.Capabilities.Caps userCaps = capsModule.GetCapsForUser(ua.PrincipalID);
+            PollServiceEventArgs pseArgs;
+            userCaps.TryGetPollHandler("FetchInventoryDescendents2", out pseArgs);
+            req.UriPath = pseArgs.Url;
+            req.Uri = new Uri("file://" + req.UriPath);
+
+            // Retrieve root folder details directly so that we can request
+            InventoryFolderBase folder = scene.InventoryService.GetRootFolder(ua.PrincipalID);
+
+            OSDMap osdFolder = new OSDMap();
+            osdFolder["folder_id"] = folder.ID;
+            osdFolder["owner_id"] = ua.PrincipalID;
+            osdFolder["fetch_folders"] = true;
+            osdFolder["fetch_items"] = true;
+            osdFolder["sort_order"] = 0;
+
+            OSDArray osdFoldersArray = new OSDArray();
+            osdFoldersArray.Add(osdFolder);
+
+            OSDMap osdReqMap = new OSDMap();
+            osdReqMap["folders"] = osdFoldersArray;
+
+            req.Body = new MemoryStream(OSDParser.SerializeLLSDXmlBytes(osdReqMap));
+
+            TestHttpClientContext context = new TestHttpClientContext(false);
+
+            // WARNING: This results in a caught exception, because queryString is null
+            MainServer.Instance.OnRequest(context, new RequestEventArgs(req));
+
+            // Drive processing of the queued inventory request synchronously.
+            wfidModule.WaitProcessQueuedInventoryRequest();
+            MainServer.Instance.PollServiceRequestManager.WaitPerformResponse();
+
+//            System.Threading.Thread.Sleep(10000);
+
+            OSDMap responseOsd = (OSDMap)OSDParser.DeserializeLLSDXml(context.ResponseBody);
+            OSDArray foldersOsd = (OSDArray)responseOsd["folders"];
+            OSDMap folderOsd = (OSDMap)foldersOsd[0];
+
+            // A sanity check that the response has the expected number of descendents for a default inventory
+            // TODO: Need a more thorough check.
+            Assert.That((int)folderOsd["descendents"], Is.EqualTo(16));
+        }
+    }
+     */
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
new file mode 100644
index 0000000..b406b37
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
@@ -0,0 +1,145 @@
+/*
+ * 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.Collections.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "UploadBakedTextureModule")]
+    public class UploadBakedTextureModule : INonSharedRegionModule
+    {
+       private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// For historical reasons this is fixed, but there
+        /// </summary>
+        private static readonly string m_uploadBakedTexturePath = "0010/";// This is in the LandManagementModule.
+
+        private Scene m_scene;
+
+        private string m_URL;
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_URL = config.GetString("Cap_UploadBakedTexture", string.Empty);
+
+//            IConfig appearanceConfig = source.Configs["Appearance"];
+        }
+
+        public void AddRegion(Scene s)
+        {
+            m_scene = s;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            s.EventManager.OnRegisterCaps -= RegisterCaps;
+            s.EventManager.OnNewPresence -= RegisterNewPresence;
+            s.EventManager.OnRemovePresence -= DeRegisterPresence;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+            m_scene.EventManager.OnNewPresence += RegisterNewPresence;
+            m_scene.EventManager.OnRemovePresence += DeRegisterPresence;
+        }
+
+        private void DeRegisterPresence(UUID agentId)
+        {
+        }
+
+        private void RegisterNewPresence(ScenePresence presence)
+        {
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "UploadBakedTextureModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            //caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
+            if (m_URL == "localhost")
+            {
+                UploadBakedTextureHandler avatarhandler = new UploadBakedTextureHandler(
+                    caps, m_scene.AssetService);
+
+                caps.RegisterHandler(
+                    "UploadBakedTexture",
+                    new RestStreamHandler(
+                        "POST",
+                        "/CAPS/" + caps.CapsObjectPath + m_uploadBakedTexturePath,
+                        avatarhandler.UploadBakedTexture,
+                        "UploadBakedTexture",
+                        agentID.ToString()));
+
+            }
+            else
+            {
+                caps.RegisterHandler("UploadBakedTexture", m_URL);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
new file mode 100644
index 0000000..8d4e561
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
@@ -0,0 +1,465 @@
+/*
+ * 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.Threading;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework.Monitoring;
+
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    /// <summary>
+    /// This module implements both WebFetchInventoryDescendents and FetchInventoryDescendents2 capabilities.
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "WebFetchInvDescModule")]
+    public class WebFetchInvDescModule : INonSharedRegionModule
+    {
+        class aPollRequest
+        {
+            public PollServiceInventoryEventArgs thepoll;
+            public UUID reqID;
+            public Hashtable request;
+            public ScenePresence presence;
+            public List<UUID> folders;
+        }
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Control whether requests will be processed asynchronously.
+        /// </summary>
+        /// <remarks>
+        /// Defaults to true.  Can currently not be changed once a region has been added to the module.
+        /// </remarks>
+        public bool ProcessQueuedRequestsAsync { get; private set; }
+
+        /// <summary>
+        /// Number of inventory requests processed by this module.
+        /// </summary>
+        /// <remarks>
+        /// It's the PollServiceRequestManager that actually sends completed requests back to the requester.
+        /// </remarks>
+        public static int ProcessedRequestsCount { get; set; }
+
+        private static Stat s_queuedRequestsStat;
+        private static Stat s_processedRequestsStat;
+
+        public Scene Scene { get; private set; }
+
+        private IInventoryService m_InventoryService;
+        private ILibraryService m_LibraryService;
+
+        private bool m_Enabled;
+
+        private string m_fetchInventoryDescendents2Url;
+//        private string m_webFetchInventoryDescendentsUrl;
+
+        private static FetchInvDescHandler m_webFetchHandler;
+
+        private static Thread[] m_workerThreads = null;
+
+        private static OpenSim.Framework.BlockingQueue<aPollRequest> m_queue =
+                new OpenSim.Framework.BlockingQueue<aPollRequest>();
+
+        private static int m_NumberScenes = 0;
+
+        #region ISharedRegionModule Members
+
+        public WebFetchInvDescModule() : this(true) {}
+
+        public WebFetchInvDescModule(bool processQueuedResultsAsync)
+        {
+            ProcessQueuedRequestsAsync = processQueuedResultsAsync;
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_fetchInventoryDescendents2Url = config.GetString("Cap_FetchInventoryDescendents2", string.Empty);
+//            m_webFetchInventoryDescendentsUrl = config.GetString("Cap_WebFetchInventoryDescendents", string.Empty);
+
+//            if (m_fetchInventoryDescendents2Url != string.Empty || m_webFetchInventoryDescendentsUrl != string.Empty)
+            if (m_fetchInventoryDescendents2Url != string.Empty)
+            {
+                m_Enabled = true;
+            }
+        }
+
+        public void AddRegion(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            Scene = s;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            Scene.EventManager.OnRegisterCaps -= RegisterCaps;
+
+            StatsManager.DeregisterStat(s_processedRequestsStat);
+            StatsManager.DeregisterStat(s_queuedRequestsStat);
+
+            m_NumberScenes--;
+            Scene = null;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            if (s_processedRequestsStat == null)
+                s_processedRequestsStat =
+                    new Stat(
+                        "ProcessedFetchInventoryRequests",
+                        "Number of processed fetch inventory requests",
+                        "These have not necessarily yet been dispatched back to the requester.",
+                        "",
+                        "inventory",
+                        "httpfetch",
+                        StatType.Pull,
+                        MeasuresOfInterest.AverageChangeOverTime,
+                        stat => { stat.Value = ProcessedRequestsCount; },
+                        StatVerbosity.Debug);
+
+            if (s_queuedRequestsStat == null)
+                s_queuedRequestsStat =
+                    new Stat(
+                        "QueuedFetchInventoryRequests",
+                        "Number of fetch inventory requests queued for processing",
+                        "",
+                        "",
+                        "inventory",
+                        "httpfetch",
+                        StatType.Pull,
+                        MeasuresOfInterest.AverageChangeOverTime,
+                        stat => { stat.Value = m_queue.Count(); },
+                        StatVerbosity.Debug);
+
+            StatsManager.RegisterStat(s_processedRequestsStat);
+            StatsManager.RegisterStat(s_queuedRequestsStat);
+
+            m_InventoryService = Scene.InventoryService;
+            m_LibraryService = Scene.LibraryService;
+
+            // We'll reuse the same handler for all requests.
+            m_webFetchHandler = new FetchInvDescHandler(m_InventoryService, m_LibraryService, Scene);
+
+            Scene.EventManager.OnRegisterCaps += RegisterCaps;
+
+            m_NumberScenes++;
+
+            int nworkers = 2; // was 2
+            if (ProcessQueuedRequestsAsync && m_workerThreads == null)
+            {
+                m_workerThreads = new Thread[nworkers];
+
+                for (uint i = 0; i < nworkers; i++)
+                {
+                    m_workerThreads[i] = WorkManager.StartThread(DoInventoryRequests,
+                            String.Format("InventoryWorkerThread{0}", i),
+                            ThreadPriority.Normal,
+                            true,
+                            true,
+                            null,
+                            int.MaxValue);
+                }
+            }
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+            if (!m_Enabled)
+                return;
+
+            if (ProcessQueuedRequestsAsync)
+            {
+                if (m_NumberScenes <= 0 && m_workerThreads != null)
+                {
+                    m_log.DebugFormat("[WebFetchInvDescModule] Closing");
+                    foreach (Thread t in m_workerThreads)
+                        Watchdog.AbortThread(t.ManagedThreadId);
+
+                    m_workerThreads = null;
+                }
+            }
+        }
+
+        public string Name { get { return "WebFetchInvDescModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        private class PollServiceInventoryEventArgs : PollServiceEventArgs
+        {
+            private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+            private Dictionary<UUID, Hashtable> responses =
+                    new Dictionary<UUID, Hashtable>();
+
+            private WebFetchInvDescModule m_module;
+
+            public PollServiceInventoryEventArgs(WebFetchInvDescModule module, string url, UUID pId) :
+                base(null, url, null, null, null, pId, int.MaxValue)
+            {
+                m_module = module;
+
+                HasEvents = (x, y) => { lock (responses) return responses.ContainsKey(x); };
+                GetEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        try
+                        {
+                            return responses[x];
+                        }
+                        finally
+                        {
+                            responses.Remove(x);
+                        }
+                    }
+                };
+
+                Request = (x, y) =>
+                {
+                    ScenePresence sp = m_module.Scene.GetScenePresence(Id);
+
+                    aPollRequest reqinfo = new aPollRequest();
+                    reqinfo.thepoll = this;
+                    reqinfo.reqID = x;
+                    reqinfo.request = y;
+                    reqinfo.presence = sp;
+                    reqinfo.folders = new List<UUID>();
+
+                    // Decode the request here
+                    string request = y["body"].ToString();
+
+                    request = request.Replace("<string>00000000-0000-0000-0000-000000000000</string>", "<uuid>00000000-0000-0000-0000-000000000000</uuid>");
+
+                    request = request.Replace("<key>fetch_folders</key><integer>0</integer>", "<key>fetch_folders</key><boolean>0</boolean>");
+                    request = request.Replace("<key>fetch_folders</key><integer>1</integer>", "<key>fetch_folders</key><boolean>1</boolean>");
+
+                    Hashtable hash = new Hashtable();
+                    try
+                    {
+                        hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+                    }
+                    catch (LLSD.LLSDParseException e)
+                    {
+                        m_log.ErrorFormat("[INVENTORY]: Fetch error: {0}{1}" + e.Message, e.StackTrace);
+                        m_log.Error("Request: " + request);
+                        return;
+                    }
+                    catch (System.Xml.XmlException)
+                    {
+                        m_log.ErrorFormat("[INVENTORY]: XML Format error");
+                    }
+
+                    ArrayList foldersrequested = (ArrayList)hash["folders"];
+
+                    bool highPriority = false;
+
+                    for (int i = 0; i < foldersrequested.Count; i++)
+                    {
+                        Hashtable inventoryhash = (Hashtable)foldersrequested[i];
+                        string folder = inventoryhash["folder_id"].ToString();
+                        UUID folderID;
+                        if (UUID.TryParse(folder, out folderID))
+                        {
+                            if (!reqinfo.folders.Contains(folderID))
+                            {
+                                if (sp.COF != UUID.Zero && sp.COF == folderID)
+                                    highPriority = true;
+                                reqinfo.folders.Add(folderID);
+                            }
+                        }
+                    }
+
+                    if (highPriority)
+                        m_queue.PriorityEnqueue(reqinfo);
+                    else
+                        m_queue.Enqueue(reqinfo);
+                };
+
+                NoEvents = (x, y) =>
+                {
+/*
+                    lock (requests)
+                    {
+                        Hashtable request = requests.Find(id => id["RequestID"].ToString() == x.ToString());
+                        requests.Remove(request);
+                    }
+*/
+                    Hashtable response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    return response;
+                };
+            }
+
+            public void Process(aPollRequest requestinfo)
+            {
+                if(m_module == null || m_module.Scene == null || m_module.Scene.ShuttingDown)
+                    return;
+
+                UUID requestID = requestinfo.reqID;
+
+                Hashtable response = new Hashtable();
+
+                response["int_response_code"] = 200;
+                response["content_type"] = "text/plain";
+                response["keepalive"] = false;
+                response["reusecontext"] = false;
+
+                response["str_response_string"] = m_webFetchHandler.FetchInventoryDescendentsRequest(
+                        requestinfo.request["body"].ToString(), String.Empty, String.Empty, null, null);
+
+                lock (responses)
+                {
+                    if (responses.ContainsKey(requestID))
+                        m_log.WarnFormat("[FETCH INVENTORY DESCENDENTS2 MODULE]: Caught in the act of loosing responses! Please report this on mantis #7054");
+                    responses[requestID] = response;
+                }
+                requestinfo.folders.Clear();
+                requestinfo.request.Clear();
+                WebFetchInvDescModule.ProcessedRequestsCount++;
+            }
+        }
+
+        private void RegisterCaps(UUID agentID, Caps caps)
+        {
+            RegisterFetchDescendentsCap(agentID, caps, "FetchInventoryDescendents2", m_fetchInventoryDescendents2Url);
+        }
+
+        private void RegisterFetchDescendentsCap(UUID agentID, Caps caps, string capName, string url)
+        {
+            string capUrl;
+
+            // disable the cap clause
+            if (url == "")
+            {
+                return;
+            }
+            // handled by the simulator
+            else if (url == "localhost")
+            {
+                capUrl = "/CAPS/" + UUID.Random() + "/";
+
+                // Register this as a poll service
+                PollServiceInventoryEventArgs args = new PollServiceInventoryEventArgs(this, capUrl, agentID);
+                args.Type = PollServiceEventArgs.EventType.Inventory;
+
+                caps.RegisterPollHandler(capName, args);
+            }
+            // external handler
+            else
+            {
+                capUrl = url;
+                IExternalCapsModule handler = Scene.RequestModuleInterface<IExternalCapsModule>();
+                if (handler != null)
+                    handler.RegisterExternalUserCapsHandler(agentID,caps,capName,capUrl);
+                else
+                    caps.RegisterHandler(capName, capUrl);
+            }
+
+            // m_log.DebugFormat(
+            //     "[FETCH INVENTORY DESCENDENTS2 MODULE]: Registered capability {0} at {1} in region {2} for {3}",
+            //     capName, capUrl, m_scene.RegionInfo.RegionName, agentID);
+        }
+
+//        private void DeregisterCaps(UUID agentID, Caps caps)
+//        {
+//            string capUrl;
+//
+//            if (m_capsDict.TryGetValue(agentID, out capUrl))
+//            {
+//                MainServer.Instance.RemoveHTTPHandler("", capUrl);
+//                m_capsDict.Remove(agentID);
+//            }
+//        }
+
+        private static void DoInventoryRequests()
+        {
+            while (true)
+            {
+                aPollRequest poolreq = m_queue.Dequeue(4500);
+                Watchdog.UpdateThread();
+
+                if (poolreq != null && poolreq.thepoll != null)
+                {
+                    try
+                    {
+                        poolreq.thepoll.Process(poolreq);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[INVENTORY]: Failed to process queued inventory request {0} for {1}.  Exception {2}",
+                            poolreq.reqID, poolreq.presence != null ? poolreq.presence.Name : "unknown", e);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacket.cs b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacket.cs
new file mode 100644
index 0000000..e22670b
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacket.cs
@@ -0,0 +1,63 @@
+/*
+ * 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 OpenSim.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    /// <summary>
+    /// Holds a reference to a <seealso cref="LLUDPClient"/> and a <seealso cref="Packet"/>
+    /// for incoming packets
+    /// </summary>
+    public sealed class IncomingPacket
+    {
+        /// <summary>Client this packet came from</summary>
+        public LLClientView Client;
+
+        /// <summary>Packet data that has been received</summary>
+        public Packet Packet;
+
+        /// <summary>
+        /// No arg constructor.
+        /// </summary>
+        public IncomingPacket() {}
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="client">Reference to the client this packet came from</param>
+        /// <param name="packet">Packet data</param>
+        public IncomingPacket(LLClientView client, Packet packet)
+        {
+            Client = client;
+            Packet = packet;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacketHistoryCollection.cs b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacketHistoryCollection.cs
new file mode 100644
index 0000000..1f73a1d
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacketHistoryCollection.cs
@@ -0,0 +1,73 @@
+/*
+ * 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;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    /// <summary>
+    /// A circular buffer and hashset for tracking incoming packet sequence
+    /// numbers
+    /// </summary>
+    public sealed class IncomingPacketHistoryCollection
+    {
+        private readonly uint[] m_items;
+        private HashSet<uint> m_hashSet;
+        private int m_first;
+        private int m_next;
+        private int m_capacity;
+
+        public IncomingPacketHistoryCollection(int capacity)
+        {
+            this.m_capacity = capacity;
+            m_items = new uint[capacity];
+            m_hashSet = new HashSet<uint>();
+        }
+
+        public bool TryEnqueue(uint ack)
+        {
+            lock (m_hashSet)
+            {
+                if (m_hashSet.Add(ack))
+                {
+                    m_items[m_next] = ack;
+                    m_next = (m_next + 1) % m_capacity;
+                    if (m_next == m_first)
+                    {
+                        m_hashSet.Remove(m_items[m_first]);
+                        m_first = (m_first + 1) % m_capacity;
+                    }
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs b/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs
new file mode 100644
index 0000000..0a6785c
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs
@@ -0,0 +1,441 @@
+/*
+ * 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 OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+using log4net;
+using System.Reflection;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    /// <summary>
+    /// Stores information about a current texture download and a reference to the texture asset
+    /// </summary>
+    public class J2KImage
+    {
+        private const int IMAGE_PACKET_SIZE = 1000;
+        private const int FIRST_PACKET_SIZE = 600;
+
+        /// <summary>
+        /// If we've requested an asset but not received it in this ticks timeframe, then allow a duplicate
+        /// request from the client to trigger a fresh asset request.
+        /// </summary>
+        /// <remarks>
+        /// There are 10,000 ticks in a millisecond
+        /// </remarks>
+        private const int ASSET_REQUEST_TIMEOUT = 100000000;
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public uint LastSequence;
+        public float Priority;
+        public uint StartPacket;
+        public sbyte DiscardLevel;
+        public UUID TextureID;
+        public IJ2KDecoder J2KDecoder;
+        public IAssetService AssetService;
+        public UUID AgentID;
+        public IInventoryAccessModule InventoryAccessModule;
+        private OpenJPEG.J2KLayerInfo[] m_layers;
+
+        /// <summary>
+        /// Has this request decoded the asset data?
+        /// </summary>
+        public bool IsDecoded { get; private set; }
+
+        /// <summary>
+        /// Has this request received the required asset data?
+        /// </summary>
+        public bool HasAsset { get; private set; }
+
+        /// <summary>
+        /// Time in milliseconds at which the asset was requested.
+        /// </summary>
+        public long AssetRequestTime { get; private set; }
+
+        public C5.IPriorityQueueHandle<J2KImage> PriorityQueueHandle;
+
+        private uint m_currentPacket;
+        private bool m_decodeRequested;
+        private bool m_assetRequested;
+        private bool m_sentInfo;
+        private uint m_stopPacket;
+        private byte[] m_asset;
+        private LLImageManager m_imageManager;
+
+        public J2KImage(LLImageManager imageManager)
+        {
+            m_imageManager = imageManager;
+        }
+
+        /// <summary>
+        /// Sends packets for this texture to a client until packetsToSend is
+        /// hit or the transfer completes
+        /// </summary>
+        /// <param name="client">Reference to the client that the packets are destined for</param>
+        /// <param name="packetsToSend">Maximum number of packets to send during this call</param>
+        /// <param name="packetsSent">Number of packets sent during this call</param>
+        /// <returns>True if the transfer completes at the current discard level, otherwise false</returns>
+        public bool SendPackets(IClientAPI client, int packetsToSend, out int packetsSent)
+        {
+            packetsSent = 0;
+
+            if (m_currentPacket <= m_stopPacket)
+            {
+                bool sendMore = true;
+
+                if (!m_sentInfo || (m_currentPacket == 0))
+                {
+                    sendMore = !SendFirstPacket(client);
+
+                    m_sentInfo = true;
+                    ++m_currentPacket;
+                    ++packetsSent;
+                }
+                if (m_currentPacket < 2)
+                {
+                    m_currentPacket = 2;
+                }
+
+                while (sendMore && packetsSent < packetsToSend && m_currentPacket <= m_stopPacket)
+                {
+                    sendMore = SendPacket(client);
+                    ++m_currentPacket;
+                    ++packetsSent;
+                }
+            }
+
+            return (m_currentPacket > m_stopPacket);
+        }
+
+        /// <summary>
+        /// This is where we decide what we need to update
+        /// and assign the real discardLevel and packetNumber
+        /// assuming of course that the connected client might be bonkers
+        /// </summary>
+        public void RunUpdate()
+        {
+            if (!HasAsset)
+            {
+                if (!m_assetRequested || DateTime.UtcNow.Ticks > AssetRequestTime + ASSET_REQUEST_TIMEOUT)
+                {
+//                    m_log.DebugFormat(
+//                        "[J2KIMAGE]: Requesting asset {0} from request in packet {1}, already requested? {2}, due to timeout? {3}",
+//                        TextureID, LastSequence, m_assetRequested, DateTime.UtcNow.Ticks > AssetRequestTime + ASSET_REQUEST_TIMEOUT);
+
+                    m_assetRequested = true;
+                    AssetRequestTime = DateTime.UtcNow.Ticks;
+
+                    AssetService.Get(TextureID.ToString(), this, AssetReceived);
+                }
+            }
+            else
+            {
+                if (!IsDecoded)
+                {
+                    //We need to decode the requested image first
+                    if (!m_decodeRequested)
+                    {
+                        //Request decode
+                        m_decodeRequested = true;
+
+//                        m_log.DebugFormat("[J2KIMAGE]: Requesting decode of asset {0}", TextureID);
+
+                        // Do we have a jpeg decoder?
+                        if (J2KDecoder != null)
+                        {
+                            if (m_asset == null)
+                            {
+                                J2KDecodedCallback(TextureID, new OpenJPEG.J2KLayerInfo[0]);
+                            }
+                            else
+                            {
+                                // Send it off to the jpeg decoder
+                                J2KDecoder.BeginDecode(TextureID, m_asset, J2KDecodedCallback);
+                            }
+                        }
+                        else
+                        {
+                            J2KDecodedCallback(TextureID, new OpenJPEG.J2KLayerInfo[0]);
+                        }
+                    }
+                }
+                else
+                {
+                    // Check for missing image asset data
+                    if (m_asset == null)
+                    {
+                        m_log.Warn("[J2KIMAGE]: RunUpdate() called with missing asset data (no missing image texture?). Canceling texture transfer");
+                        m_currentPacket = m_stopPacket;
+                        return;
+                    }
+
+                    if (DiscardLevel >= 0 || m_stopPacket == 0)
+                    {
+                        // This shouldn't happen, but if it does, we really can't proceed
+                        if (m_layers == null)
+                        {
+                            m_log.Warn("[J2KIMAGE]: RunUpdate() called with missing Layers. Canceling texture transfer");
+                            m_currentPacket = m_stopPacket;
+                            return;
+                        }
+
+                        int maxDiscardLevel = Math.Max(0, m_layers.Length - 1);
+
+                        // Treat initial texture downloads with a DiscardLevel of -1 a request for the highest DiscardLevel
+                        if (DiscardLevel < 0 && m_stopPacket == 0)
+                            DiscardLevel = (sbyte)maxDiscardLevel;
+
+                        // Clamp at the highest discard level
+                        DiscardLevel = (sbyte)Math.Min(DiscardLevel, maxDiscardLevel);
+
+                        //Calculate the m_stopPacket
+                        if (m_layers.Length > 0)
+                        {
+                            m_stopPacket = (uint)GetPacketForBytePosition(m_layers[(m_layers.Length - 1) - DiscardLevel].End);
+                            //I don't know why, but the viewer seems to expect the final packet if the file
+                            //is just one packet bigger.
+                            if (TexturePacketCount() == m_stopPacket + 1)
+                            {
+                                m_stopPacket = TexturePacketCount();
+                            }
+                        }
+                        else
+                        {
+                            m_stopPacket = TexturePacketCount();
+                        }
+
+                        //Give them at least two packets, to play nice with some broken viewers (SL also behaves this way)
+                        if (m_stopPacket == 1 && m_layers[0].End > FIRST_PACKET_SIZE) m_stopPacket++;
+
+                        m_currentPacket = StartPacket;
+                    }
+                }
+            }
+        }
+
+        private bool SendFirstPacket(IClientAPI client)
+        {
+            if (client == null)
+                return false;
+
+            if (m_asset == null)
+            {
+                m_log.Warn("[J2KIMAGE]: Sending ImageNotInDatabase for texture " + TextureID);
+                client.SendImageNotFound(TextureID);
+                return true;
+            }
+            else if (m_asset.Length <= FIRST_PACKET_SIZE)
+            {
+                // We have less then one packet's worth of data
+                client.SendImageFirstPart(1, TextureID, (uint)m_asset.Length, m_asset, 2);
+                m_stopPacket = 0;
+                return true;
+            }
+            else
+            {
+                // This is going to be a multi-packet texture download
+                byte[] firstImageData = new byte[FIRST_PACKET_SIZE];
+
+                try { Buffer.BlockCopy(m_asset, 0, firstImageData, 0, FIRST_PACKET_SIZE); }
+                catch (Exception)
+                {
+                    m_log.ErrorFormat("[J2KIMAGE]: Texture block copy for the first packet failed. textureid={0}, assetlength={1}", TextureID, m_asset.Length);
+                    return true;
+                }
+
+                client.SendImageFirstPart(TexturePacketCount(), TextureID, (uint)m_asset.Length, firstImageData, (byte)ImageCodec.J2C);
+            }
+            return false;
+        }
+
+        private bool SendPacket(IClientAPI client)
+        {
+            if (client == null)
+                return false;
+
+            bool complete = false;
+            int imagePacketSize = ((int)m_currentPacket == (TexturePacketCount())) ? LastPacketSize() : IMAGE_PACKET_SIZE;
+
+            try
+            {
+                if ((CurrentBytePosition() + IMAGE_PACKET_SIZE) > m_asset.Length)
+                {
+                    imagePacketSize = LastPacketSize();
+                    complete = true;
+                    if ((CurrentBytePosition() + imagePacketSize) > m_asset.Length)
+                    {
+                        imagePacketSize = m_asset.Length - CurrentBytePosition();
+                        complete = true;
+                    }
+                }
+
+                // It's concievable that the client might request packet one
+                // from a one packet image, which is really packet 0,
+                // which would leave us with a negative imagePacketSize..
+                if (imagePacketSize > 0)
+                {
+                    byte[] imageData = new byte[imagePacketSize];
+                    int currentPosition = CurrentBytePosition();
+
+                    try { Buffer.BlockCopy(m_asset, currentPosition, imageData, 0, imagePacketSize); }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("[J2KIMAGE]: Texture block copy for the first packet failed. textureid={0}, assetlength={1}, currentposition={2}, imagepacketsize={3}, exception={4}",
+                            TextureID, m_asset.Length, currentPosition, imagePacketSize, e.Message);
+                        return false;
+                    }
+
+                    //Send the packet
+                    client.SendImageNextPart((ushort)(m_currentPacket - 1), TextureID, imageData);
+                }
+
+                return !complete;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+
+        private ushort TexturePacketCount()
+        {
+            if (!IsDecoded)
+                return 0;
+
+            if (m_asset == null)
+                return 0;
+
+            if (m_asset.Length <= FIRST_PACKET_SIZE)
+                return 1;
+
+            return (ushort)(((m_asset.Length - FIRST_PACKET_SIZE + IMAGE_PACKET_SIZE - 1) / IMAGE_PACKET_SIZE) + 1);
+        }
+
+        private int GetPacketForBytePosition(int bytePosition)
+        {
+            return ((bytePosition - FIRST_PACKET_SIZE + IMAGE_PACKET_SIZE - 1) / IMAGE_PACKET_SIZE) + 1;
+        }
+
+        private int LastPacketSize()
+        {
+            if (m_currentPacket == 1)
+                return m_asset.Length;
+            int lastsize = (m_asset.Length - FIRST_PACKET_SIZE) % IMAGE_PACKET_SIZE;
+            //If the last packet size is zero, it's really cImagePacketSize, it sits on the boundary
+            if (lastsize == 0)
+            {
+                lastsize = IMAGE_PACKET_SIZE;
+            }
+            return lastsize;
+        }
+
+        private int CurrentBytePosition()
+        {
+            if (m_currentPacket == 0)
+                return 0;
+
+            if (m_currentPacket == 1)
+                return FIRST_PACKET_SIZE;
+
+            int result = FIRST_PACKET_SIZE + ((int)m_currentPacket - 2) * IMAGE_PACKET_SIZE;
+
+            if (result < 0)
+                result = FIRST_PACKET_SIZE;
+
+            return result;
+        }
+
+        private void J2KDecodedCallback(UUID AssetId, OpenJPEG.J2KLayerInfo[] layers)
+        {
+            m_layers = layers;
+            IsDecoded = true;
+            RunUpdate();
+        }
+
+        private void AssetDataCallback(UUID AssetID, AssetBase asset)
+        {
+            HasAsset = true;
+
+            if (asset == null || asset.Data == null)
+            {
+                if (m_imageManager.MissingImage != null)
+                {
+                    m_asset = m_imageManager.MissingImage.Data;
+                }
+                else
+                {
+                    m_asset = null;
+                    IsDecoded = true;
+                }
+            }
+            else
+            {
+                m_asset = asset.Data;
+            }
+
+            RunUpdate();
+        }
+
+        private void AssetReceived(string id, Object sender, AssetBase asset)
+        {
+//            m_log.DebugFormat(
+//                "[J2KIMAGE]: Received asset {0} ({1} bytes)", id, asset != null ? asset.Data.Length.ToString() : "n/a");
+
+            UUID assetID = UUID.Zero;
+            if (asset != null)
+            {
+                assetID = asset.FullID;
+            }
+            else if ((InventoryAccessModule != null) && (sender != InventoryAccessModule))
+            {
+                // Unfortunately we need this here, there's no other way.
+                // This is due to the fact that textures opened directly from the agent's inventory
+                // don't have any distinguishing feature. As such, in order to serve those when the
+                // foreign user is visiting, we need to try again after the first fail to the local
+                // asset service.
+                string assetServerURL = string.Empty;
+                if (InventoryAccessModule.IsForeignUser(AgentID, out assetServerURL) && !string.IsNullOrEmpty(assetServerURL))
+                {
+                    if (!assetServerURL.EndsWith("/") && !assetServerURL.EndsWith("="))
+                        assetServerURL = assetServerURL + "/";
+
+//                    m_log.DebugFormat("[J2KIMAGE]: texture {0} not found in local asset storage. Trying user's storage.", assetServerURL + id);
+                    AssetService.Get(assetServerURL + id, InventoryAccessModule, AssetReceived);
+                    return;
+                }
+            }
+
+            AssetDataCallback(assetID, asset);
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
new file mode 100644
index 0000000..c18f587
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -0,0 +1,13979 @@
+/*
+ * 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.Net;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Timers;
+using System.Xml;
+
+using log4net;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenMetaverse.Messages.Linden;
+using OpenMetaverse.StructuredData;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Client;
+using OpenSim.Framework.Monitoring;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Timer = System.Timers.Timer;
+using AssetLandmark = OpenSim.Framework.AssetLandmark;
+using RegionFlags = OpenMetaverse.RegionFlags;
+
+using System.IO;
+using PermissionMask = OpenSim.Framework.PermissionMask;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    public delegate bool PacketMethod(IClientAPI simClient, Packet packet);
+
+    /// <summary>
+    /// Handles new client connections
+    /// Constructor takes a single Packet and authenticates everything
+    /// </summary>
+    public class LLClientView : IClientAPI, IClientCore, IClientIM, IClientChat, IClientInventory, IStatsCollector, IClientIPEndpoint
+    {
+        /// <value>
+        /// Debug packet level.  See OpenSim.RegisterConsoleCommands() for more details.
+        /// </value>
+        public int DebugPacketLevel { get; set; }
+
+        #region Events
+
+        public event BinaryGenericMessage OnBinaryGenericMessage;
+        public event Action<IClientAPI> OnLogout;
+        public event ObjectPermissions OnObjectPermissions;
+        public event Action<IClientAPI> OnConnectionClosed;
+        public event ViewerEffectEventHandler OnViewerEffect;
+        public event ImprovedInstantMessage OnInstantMessage;
+        public event ChatMessage OnChatFromClient;
+        public event RezObject OnRezObject;
+        public event DeRezObject OnDeRezObject;
+        public event RezRestoreToWorld OnRezRestoreToWorld;
+        public event ModifyTerrain OnModifyTerrain;
+        public event Action<IClientAPI> OnRegionHandShakeReply;
+        public event GenericCall1 OnRequestWearables;
+        public event SetAppearance OnSetAppearance;
+        public event AvatarNowWearing OnAvatarNowWearing;
+        public event RezSingleAttachmentFromInv OnRezSingleAttachmentFromInv;
+        public event RezMultipleAttachmentsFromInv OnRezMultipleAttachmentsFromInv;
+        public event UUIDNameRequest OnDetachAttachmentIntoInv;
+        public event ObjectAttach OnObjectAttach;
+        public event ObjectDeselect OnObjectDetach;
+        public event ObjectDrop OnObjectDrop;
+        public event Action<IClientAPI, bool> OnCompleteMovementToRegion;
+        public event UpdateAgent OnPreAgentUpdate;
+        public event UpdateAgent OnAgentUpdate;
+        public event UpdateAgent OnAgentCameraUpdate;
+        public event AgentRequestSit OnAgentRequestSit;
+        public event AgentSit OnAgentSit;
+        public event AvatarPickerRequest OnAvatarPickerRequest;
+        public event StartAnim OnStartAnim;
+        public event StopAnim OnStopAnim;
+        public event ChangeAnim OnChangeAnim;
+        public event Action<IClientAPI> OnRequestAvatarsData;
+        public event LinkObjects OnLinkObjects;
+        public event DelinkObjects OnDelinkObjects;
+        public event GrabObject OnGrabObject;
+        public event DeGrabObject OnDeGrabObject;
+        public event SpinStart OnSpinStart;
+        public event SpinStop OnSpinStop;
+        public event ObjectDuplicate OnObjectDuplicate;
+        public event ObjectDuplicateOnRay OnObjectDuplicateOnRay;
+        public event MoveObject OnGrabUpdate;
+        public event SpinObject OnSpinUpdate;
+        public event AddNewPrim OnAddPrim;
+        public event RequestGodlikePowers OnRequestGodlikePowers;
+        public event GodKickUser OnGodKickUser;
+        public event ObjectExtraParams OnUpdateExtraParams;
+        public event UpdateShape OnUpdatePrimShape;
+        public event ObjectRequest OnObjectRequest;
+        public event ObjectSelect OnObjectSelect;
+        public event ObjectDeselect OnObjectDeselect;
+        public event GenericCall7 OnObjectDescription;
+        public event GenericCall7 OnObjectName;
+        public event GenericCall7 OnObjectClickAction;
+        public event GenericCall7 OnObjectMaterial;
+        public event ObjectIncludeInSearch OnObjectIncludeInSearch;
+        public event RequestObjectPropertiesFamily OnRequestObjectPropertiesFamily;
+        public event UpdatePrimFlags OnUpdatePrimFlags;
+        public event UpdatePrimTexture OnUpdatePrimTexture;
+        public event ClientChangeObject onClientChangeObject;
+        public event UpdateVector OnUpdatePrimGroupPosition;
+        public event UpdateVector OnUpdatePrimSinglePosition;
+        public event UpdatePrimRotation OnUpdatePrimGroupRotation;
+        public event UpdatePrimSingleRotation OnUpdatePrimSingleRotation;
+        public event UpdatePrimSingleRotationPosition OnUpdatePrimSingleRotationPosition;
+        public event UpdatePrimGroupRotation OnUpdatePrimGroupMouseRotation;
+        public event UpdateVector OnUpdatePrimScale;
+        public event UpdateVector OnUpdatePrimGroupScale;
+        public event RequestMapBlocks OnRequestMapBlocks;
+        public event RequestMapName OnMapNameRequest;
+        public event TeleportLocationRequest OnTeleportLocationRequest;
+        public event TeleportLandmarkRequest OnTeleportLandmarkRequest;
+        public event TeleportCancel OnTeleportCancel;
+        public event RequestAvatarProperties OnRequestAvatarProperties;
+        public event SetAlwaysRun OnSetAlwaysRun;
+        public event FetchInventory OnAgentDataUpdateRequest;
+        public event TeleportLocationRequest OnSetStartLocationRequest;
+        public event UpdateAvatarProperties OnUpdateAvatarProperties;
+        public event CreateNewInventoryItem OnCreateNewInventoryItem;
+        public event LinkInventoryItem OnLinkInventoryItem;
+        public event CreateInventoryFolder OnCreateNewInventoryFolder;
+        public event UpdateInventoryFolder OnUpdateInventoryFolder;
+        public event MoveInventoryFolder OnMoveInventoryFolder;
+        public event FetchInventoryDescendents OnFetchInventoryDescendents;
+        public event PurgeInventoryDescendents OnPurgeInventoryDescendents;
+        public event FetchInventory OnFetchInventory;
+        public event RequestTaskInventory OnRequestTaskInventory;
+        public event UpdateInventoryItem OnUpdateInventoryItem;
+        public event CopyInventoryItem OnCopyInventoryItem;
+        public event MoveItemsAndLeaveCopy OnMoveItemsAndLeaveCopy;
+        public event MoveInventoryItem OnMoveInventoryItem;
+        public event RemoveInventoryItem OnRemoveInventoryItem;
+        public event RemoveInventoryFolder OnRemoveInventoryFolder;
+        public event UDPAssetUploadRequest OnAssetUploadRequest;
+        public event XferReceive OnXferReceive;
+        public event RequestXfer OnRequestXfer;
+        public event ConfirmXfer OnConfirmXfer;
+        public event AbortXfer OnAbortXfer;
+        public event RequestTerrain OnRequestTerrain;
+        public event RezScript OnRezScript;
+        public event UpdateTaskInventory OnUpdateTaskInventory;
+        public event MoveTaskInventory OnMoveTaskItem;
+        public event RemoveTaskInventory OnRemoveTaskItem;
+        public event UUIDNameRequest OnNameFromUUIDRequest;
+        public event ParcelAccessListRequest OnParcelAccessListRequest;
+        public event ParcelAccessListUpdateRequest OnParcelAccessListUpdateRequest;
+        public event ParcelPropertiesRequest OnParcelPropertiesRequest;
+        public event ParcelDivideRequest OnParcelDivideRequest;
+        public event ParcelJoinRequest OnParcelJoinRequest;
+        public event ParcelPropertiesUpdateRequest OnParcelPropertiesUpdateRequest;
+        public event ParcelSelectObjects OnParcelSelectObjects;
+        public event ParcelObjectOwnerRequest OnParcelObjectOwnerRequest;
+        public event ParcelAbandonRequest OnParcelAbandonRequest;
+        public event ParcelGodForceOwner OnParcelGodForceOwner;
+        public event ParcelReclaim OnParcelReclaim;
+        public event ParcelReturnObjectsRequest OnParcelReturnObjectsRequest;
+        public event ParcelDeedToGroup OnParcelDeedToGroup;
+        public event RegionInfoRequest OnRegionInfoRequest;
+        public event EstateCovenantRequest OnEstateCovenantRequest;
+        public event FriendActionDelegate OnApproveFriendRequest;
+        public event FriendActionDelegate OnDenyFriendRequest;
+        public event FriendshipTermination OnTerminateFriendship;
+        public event GrantUserFriendRights OnGrantUserRights;
+        public event MoneyTransferRequest OnMoneyTransferRequest;
+        public event EconomyDataRequest OnEconomyDataRequest;
+        public event MoneyBalanceRequest OnMoneyBalanceRequest;
+        public event ParcelBuy OnParcelBuy;
+        public event UUIDNameRequest OnTeleportHomeRequest;
+        public event UUIDNameRequest OnUUIDGroupNameRequest;
+        public event ScriptAnswer OnScriptAnswer;
+        public event RequestPayPrice OnRequestPayPrice;
+        public event ObjectSaleInfo OnObjectSaleInfo;
+        public event ObjectBuy OnObjectBuy;
+        public event AgentSit OnUndo;
+        public event AgentSit OnRedo;
+        public event LandUndo OnLandUndo;
+        public event ForceReleaseControls OnForceReleaseControls;
+        public event GodLandStatRequest OnLandStatRequest;
+        public event RequestObjectPropertiesFamily OnObjectGroupRequest;
+        public event DetailedEstateDataRequest OnDetailedEstateDataRequest;
+        public event SetEstateFlagsRequest OnSetEstateFlagsRequest;
+        public event SetEstateTerrainDetailTexture OnSetEstateTerrainDetailTexture;
+        public event SetEstateTerrainTextureHeights OnSetEstateTerrainTextureHeights;
+        public event CommitEstateTerrainTextureRequest OnCommitEstateTerrainTextureRequest;
+        public event SetRegionTerrainSettings OnSetRegionTerrainSettings;
+        public event BakeTerrain OnBakeTerrain;
+        public event RequestTerrain OnUploadTerrain;
+        public event EstateChangeInfo OnEstateChangeInfo;
+        public event EstateManageTelehub OnEstateManageTelehub;
+        public event EstateRestartSimRequest OnEstateRestartSimRequest;
+        public event EstateChangeCovenantRequest OnEstateChangeCovenantRequest;
+        public event UpdateEstateAccessDeltaRequest OnUpdateEstateAccessDeltaRequest;
+        public event SimulatorBlueBoxMessageRequest OnSimulatorBlueBoxMessageRequest;
+        public event EstateBlueBoxMessageRequest OnEstateBlueBoxMessageRequest;
+        public event EstateDebugRegionRequest OnEstateDebugRegionRequest;
+        public event EstateTeleportOneUserHomeRequest OnEstateTeleportOneUserHomeRequest;
+        public event EstateTeleportAllUsersHomeRequest OnEstateTeleportAllUsersHomeRequest;
+        public event RegionHandleRequest OnRegionHandleRequest;
+        public event ParcelInfoRequest OnParcelInfoRequest;
+        public event ScriptReset OnScriptReset;
+        public event GetScriptRunning OnGetScriptRunning;
+        public event SetScriptRunning OnSetScriptRunning;
+        public event Action<Vector3, bool, bool> OnAutoPilotGo;
+        public event ActivateGesture OnActivateGesture;
+        public event DeactivateGesture OnDeactivateGesture;
+        public event ObjectOwner OnObjectOwner;
+        public event DirPlacesQuery OnDirPlacesQuery;
+        public event DirFindQuery OnDirFindQuery;
+        public event DirLandQuery OnDirLandQuery;
+        public event DirPopularQuery OnDirPopularQuery;
+        public event DirClassifiedQuery OnDirClassifiedQuery;
+        public event EventInfoRequest OnEventInfoRequest;
+        public event ParcelSetOtherCleanTime OnParcelSetOtherCleanTime;
+        public event MapItemRequest OnMapItemRequest;
+        public event OfferCallingCard OnOfferCallingCard;
+        public event AcceptCallingCard OnAcceptCallingCard;
+        public event DeclineCallingCard OnDeclineCallingCard;
+        public event SoundTrigger OnSoundTrigger;
+        public event StartLure OnStartLure;
+        public event TeleportLureRequest OnTeleportLureRequest;
+        public event NetworkStats OnNetworkStatsUpdate;
+        public event ClassifiedInfoRequest OnClassifiedInfoRequest;
+        public event ClassifiedInfoUpdate OnClassifiedInfoUpdate;
+        public event ClassifiedDelete OnClassifiedDelete;
+        public event ClassifiedGodDelete OnClassifiedGodDelete;
+        public event EventNotificationAddRequest OnEventNotificationAddRequest;
+        public event EventNotificationRemoveRequest OnEventNotificationRemoveRequest;
+        public event EventGodDelete OnEventGodDelete;
+        public event ParcelDwellRequest OnParcelDwellRequest;
+        public event UserInfoRequest OnUserInfoRequest;
+        public event UpdateUserInfo OnUpdateUserInfo;
+        public event RetrieveInstantMessages OnRetrieveInstantMessages;
+        public event PickDelete OnPickDelete;
+        public event PickGodDelete OnPickGodDelete;
+        public event PickInfoUpdate OnPickInfoUpdate;
+        public event AvatarNotesUpdate OnAvatarNotesUpdate;
+        public event MuteListRequest OnMuteListRequest;
+        public event AvatarInterestUpdate OnAvatarInterestUpdate;
+        public event PlacesQuery OnPlacesQuery;
+        public event AgentFOV OnAgentFOV;
+        public event FindAgentUpdate OnFindAgent;
+        public event TrackAgentUpdate OnTrackAgent;
+        public event NewUserReport OnUserReport;
+        public event SaveStateHandler OnSaveState;
+        public event GroupAccountSummaryRequest OnGroupAccountSummaryRequest;
+        public event GroupAccountDetailsRequest OnGroupAccountDetailsRequest;
+        public event GroupAccountTransactionsRequest OnGroupAccountTransactionsRequest;
+        public event FreezeUserUpdate OnParcelFreezeUser;
+        public event EjectUserUpdate OnParcelEjectUser;
+        public event ParcelBuyPass OnParcelBuyPass;
+        public event ParcelGodMark OnParcelGodMark;
+        public event GroupActiveProposalsRequest OnGroupActiveProposalsRequest;
+        public event GroupVoteHistoryRequest OnGroupVoteHistoryRequest;
+        public event SimWideDeletesDelegate OnSimWideDeletes;
+        public event SendPostcard OnSendPostcard;
+        public event ChangeInventoryItemFlags OnChangeInventoryItemFlags;
+        public event MuteListEntryUpdate OnUpdateMuteListEntry;
+        public event MuteListEntryRemove OnRemoveMuteListEntry;
+        public event GodlikeMessage onGodlikeMessage;
+        public event GodUpdateRegionInfoUpdate OnGodUpdateRegionInfoUpdate;
+        public event GenericCall2 OnUpdateThrottles;
+
+#pragma warning disable 0067
+        public event GenericMessage OnGenericMessage;
+        public event TextureRequest OnRequestTexture;
+        public event StatusChange OnChildAgentStatus;
+        public event GenericCall2 OnStopMovement;
+        public event Action<UUID> OnRemoveAvatar;
+        public event DisconnectUser OnDisconnectUser;
+        public event RequestAsset OnRequestAsset;
+        public event BuyObjectInventory OnBuyObjectInventory;
+        public event SetEstateTerrainBaseTexture OnSetEstateTerrainBaseTexture;
+        public event TerrainUnacked OnUnackedTerrain;
+        public event CachedTextureRequest OnCachedTextureRequest;
+#pragma warning restore 0067
+
+        #endregion Events
+
+        #region Class Members
+
+        // LLClientView Only
+        public delegate void BinaryGenericMessage(Object sender, string method, byte[][] args);
+
+        /// <summary>Used to adjust Sun Orbit values so Linden based viewers properly position sun</summary>
+        private const float m_sunPainDaHalfOrbitalCutoff = 4.712388980384689858f;
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[LLCLIENTVIEW]";
+        protected static Dictionary<PacketType, PacketMethod> PacketHandlers = new Dictionary<PacketType, PacketMethod>(); //Global/static handlers for all clients
+
+        /// <summary>
+        /// Handles UDP texture download.
+        /// </summary>
+        public LLImageManager ImageManager { get; private set; }
+
+        public JobEngine m_asyncPacketProcess;
+        private readonly LLUDPServer m_udpServer;
+        private readonly LLUDPClient m_udpClient;
+        private readonly UUID m_sessionId;
+        private readonly UUID m_secureSessionId;
+        protected readonly UUID m_agentId;
+        private readonly uint m_circuitCode;
+        private readonly byte[] m_channelVersion = Utils.EmptyBytes;
+        private readonly IGroupsModule m_GroupsModule;
+
+//        private int m_cachedTextureSerial;
+        private PriorityQueue m_entityUpdates;
+        private PriorityQueue m_entityProps;
+        private Prioritizer m_prioritizer;
+        private bool m_disableFacelights = false;
+
+        // needs optimazation
+        private HashSet<SceneObjectGroup> GroupsInView = new HashSet<SceneObjectGroup>();
+
+//        private bool m_VelocityInterpolate = false;
+        private const uint MaxTransferBytesPerPacket = 600;
+
+        /// <value>
+        /// Maintain a record of all the objects killed.  This allows us to stop an update being sent from the
+        /// thread servicing the m_primFullUpdates queue after a kill.  If this happens the object persists as an
+        /// ownerless phantom.
+        ///
+        /// All manipulation of this set has to occur under an m_entityUpdates.SyncRoot lock
+        ///
+        /// </value>
+        protected List<uint> m_killRecord;
+
+//        protected HashSet<uint> m_attachmentsSent;
+
+        private bool m_deliverPackets = true;
+
+        private bool m_SendLogoutPacketWhenClosing = true;
+
+        /// <summary>
+        /// We retain a single AgentUpdateArgs so that we can constantly reuse it rather than construct a new one for
+        /// every single incoming AgentUpdate.  Every client sends 10 AgentUpdate UDP messages per second, even if it
+        /// is doing absolutely nothing.
+        /// </summary>
+        /// <remarks>
+        /// This does mean that agent updates must be processed synchronously, at least for each client, and called methods
+        /// cannot retain a reference to it outside of that method.
+        /// </remarks>
+        private AgentUpdateArgs m_thisAgentUpdateArgs = new AgentUpdateArgs();
+
+        protected Dictionary<PacketType, PacketProcessor> m_packetHandlers = new Dictionary<PacketType, PacketProcessor>();
+        protected Dictionary<string, GenericMessage> m_genericPacketHandlers = new Dictionary<string, GenericMessage>(); //PauPaw:Local Generic Message handlers
+        protected Scene m_scene;
+        protected string m_firstName;
+        protected string m_lastName;
+        protected Vector3 m_startpos;
+        protected UUID m_activeGroupID;
+        protected string m_activeGroupName = String.Empty;
+        protected ulong m_activeGroupPowers;
+        protected Dictionary<UUID, ulong> m_groupPowers = new Dictionary<UUID, ulong>();
+        protected int m_terrainCheckerCount;
+        protected uint m_agentFOVCounter;
+
+        protected IAssetService m_assetService;
+        private const bool m_checkPackets = true;
+
+        #endregion Class Members
+
+        #region Properties
+
+        public LLUDPClient UDPClient { get { return m_udpClient; } }
+        public LLUDPServer UDPServer { get { return m_udpServer; } }
+        public IPEndPoint RemoteEndPoint { get { return m_udpClient.RemoteEndPoint; } }
+        public UUID SecureSessionId { get { return m_secureSessionId; } }
+        public IScene Scene { get { return m_scene; } }
+        public UUID SessionId { get { return m_sessionId; } }
+        public Vector3 StartPos
+        {
+            get { return m_startpos; }
+            set { m_startpos = value; }
+        }
+        public bool DeliverPackets
+        {
+            get { return m_deliverPackets; }
+            set {
+                m_deliverPackets = value;
+                m_udpClient.m_deliverPackets = value;
+            }
+        }
+        public UUID AgentId { get { return m_agentId; } }
+        public ISceneAgent SceneAgent { get; set; }
+        public UUID ActiveGroupId { get { return m_activeGroupID; } set { m_activeGroupID = value; } }
+        public string ActiveGroupName { get { return m_activeGroupName; } set { m_activeGroupName = value; } }
+        public ulong ActiveGroupPowers { get { return m_activeGroupPowers; } set { m_activeGroupPowers = value; } }
+        public bool IsGroupMember(UUID groupID) { return m_groupPowers.ContainsKey(groupID); }
+
+        public int PingTimeMS
+        {
+            get
+            {
+                if (UDPClient != null)
+                    return UDPClient.PingTimeMS;
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// Entity update queues
+        /// </summary>
+        public PriorityQueue EntityUpdateQueue { get { return m_entityUpdates; } }
+
+        /// <summary>
+        /// First name of the agent/avatar represented by the client
+        /// </summary>
+        public string FirstName { get { return m_firstName; } }
+
+        /// <summary>
+        /// Last name of the agent/avatar represented by the client
+        /// </summary>
+        public string LastName { get { return m_lastName; } }
+
+        /// <summary>
+        /// Full name of the client (first name and last name)
+        /// </summary>
+        public string Name { get { return FirstName + " " + LastName; } }
+
+        public uint CircuitCode { get { return m_circuitCode; } }
+        public int NextAnimationSequenceNumber
+        {
+            get { return m_udpServer.NextAnimationSequenceNumber; }
+        }
+
+        /// <summary>
+        /// As well as it's function in IClientAPI, in LLClientView we are locking on this property in order to
+        /// prevent race conditions by different threads calling Close().
+        /// </summary>
+        public bool IsActive { get; set; }
+
+        /// <summary>
+        /// Used to synchronise threads when client is being closed.
+        /// </summary>
+        public Object CloseSyncLock { get; private set; }
+
+        public bool IsLoggingOut { get; set; }
+
+        public bool DisableFacelights
+        {
+            get { return m_disableFacelights; }
+            set { m_disableFacelights = value; }
+        }
+
+        public List<uint> SelectedObjects {get; private set;}
+
+        public bool SendLogoutPacketWhenClosing { set { m_SendLogoutPacketWhenClosing = value; } }
+
+
+        #endregion Properties
+
+//        ~LLClientView()
+//        {
+//            m_log.DebugFormat("{0} Destructor called for {1}, circuit code {2}", LogHeader, Name, CircuitCode);
+//        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public LLClientView(Scene scene, LLUDPServer udpServer, LLUDPClient udpClient, AuthenticateResponse sessionInfo,
+            UUID agentId, UUID sessionId, uint circuitCode)
+        {
+//            DebugPacketLevel = 1;
+
+            CloseSyncLock = new Object();
+            SelectedObjects = new List<uint>();
+
+            RegisterInterface<IClientIM>(this);
+            RegisterInterface<IClientInventory>(this);
+            RegisterInterface<IClientChat>(this);
+
+            m_scene = scene;
+            m_entityUpdates = new PriorityQueue(m_scene.Entities.Count);
+            m_entityProps = new PriorityQueue(m_scene.Entities.Count);
+            m_killRecord = new List<uint>();
+//            m_attachmentsSent = new HashSet<uint>();
+
+            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
+            m_GroupsModule = scene.RequestModuleInterface<IGroupsModule>();
+            ImageManager = new LLImageManager(this, m_assetService, Scene.RequestModuleInterface<IJ2KDecoder>());
+            m_channelVersion = Util.StringToBytes256(scene.GetSimulatorVersion());
+            m_agentId = agentId;
+            m_sessionId = sessionId;
+            m_secureSessionId = sessionInfo.LoginInfo.SecureSession;
+            m_circuitCode = circuitCode;
+            m_firstName = sessionInfo.LoginInfo.First;
+            m_lastName = sessionInfo.LoginInfo.Last;
+            m_startpos = sessionInfo.LoginInfo.StartPos;
+
+            m_udpServer = udpServer;
+            m_udpClient = udpClient;
+            m_udpClient.OnQueueEmpty += HandleQueueEmpty;
+            m_udpClient.HasUpdates += HandleHasUpdates;
+            m_udpClient.OnPacketStats += PopulateStats;
+
+            m_prioritizer = new Prioritizer(m_scene);
+
+            RegisterLocalPacketHandlers();
+            string name = string.Format("AsyncInUDP-{0}",m_agentId.ToString());
+            m_asyncPacketProcess = new JobEngine(name, name, 10000);
+            IsActive = true;
+        }
+
+        #region Client Methods
+
+
+        /// <summary>
+        /// Close down the client view
+        /// </summary>
+        public void Close()
+        {
+            Close(true, false);
+        }
+
+        public void Close(bool sendStop, bool force)
+        {
+            // We lock here to prevent race conditions between two threads calling close simultaneously (e.g.
+            // a simultaneous relog just as a client is being closed out due to no packet ack from the old connection.
+            lock (CloseSyncLock)
+            {
+                // We still perform a force close inside the sync lock since this is intended to attempt close where
+                // there is some unidentified connection problem, not where we have issues due to deadlock
+                if (!IsActive && !force)
+                {
+                    m_log.DebugFormat( "{0} Not attempting to close inactive client {1} in {2} since force flag is not set",
+                        LogHeader, Name, m_scene.Name);
+
+                    return;
+                }
+
+                IsActive = false;
+                CloseWithoutChecks(sendStop);
+            }
+        }
+
+        /// <summary>
+        /// Closes down the client view without first checking whether it is active.
+        /// </summary>
+        /// <remarks>
+        /// This exists because LLUDPServer has to set IsActive = false in earlier synchronous code before calling
+        /// CloseWithoutIsActiveCheck asynchronously.
+        ///
+        /// Callers must lock ClosingSyncLock before calling.
+        /// </remarks>
+        public void CloseWithoutChecks(bool sendStop)
+        {
+            m_log.DebugFormat(
+                "[CLIENT]: Close has been called for {0} attached to scene {1}",
+                Name, m_scene.RegionInfo.RegionName);
+
+            if (sendStop)
+            {
+                // Send the STOP packet
+                DisableSimulatorPacket disable = (DisableSimulatorPacket)PacketPool.Instance.GetPacket(PacketType.DisableSimulator);
+                OutPacket(disable, ThrottleOutPacketType.Unknown);
+            }
+
+
+            // Fire the callback for this connection closing
+            if (OnConnectionClosed != null)
+                OnConnectionClosed(this);
+
+            m_asyncPacketProcess.Stop();
+
+            // Flush all of the packets out of the UDP server for this client
+            if (m_udpServer != null)
+                m_udpServer.Flush(m_udpClient);
+
+            // Remove ourselves from the scene
+            m_scene.RemoveClient(AgentId, true);
+            SceneAgent = null;
+
+            // We can't reach into other scenes and close the connection
+            // We need to do this over grid communications
+            //m_scene.CloseAllAgents(CircuitCode);
+
+            // Disable UDP handling for this client
+            m_udpClient.OnQueueEmpty -= HandleQueueEmpty;
+            m_udpClient.HasUpdates -= HandleHasUpdates;
+            m_udpClient.OnPacketStats -= PopulateStats;
+            m_udpClient.Shutdown();
+
+            // Shutdown the image manager
+            ImageManager.Close();
+            ImageManager = null;
+
+            m_entityUpdates = new PriorityQueue(1);
+            m_entityProps = new PriorityQueue(1);
+            m_killRecord.Clear();
+            GroupsInView.Clear();
+
+            if(m_scene.GetNumberOfClients() == 0)
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                GC.Collect();
+            }
+        }
+
+        public void Kick(string message)
+        {
+            if (!SceneAgent.IsChildAgent)
+            {
+                KickUserPacket kupack = (KickUserPacket)PacketPool.Instance.GetPacket(PacketType.KickUser);
+                kupack.UserInfo.AgentID = AgentId;
+                kupack.UserInfo.SessionID = SessionId;
+                kupack.TargetBlock.TargetIP = 0;
+                kupack.TargetBlock.TargetPort = 0;
+                kupack.UserInfo.Reason = Util.StringToBytes256(message);
+                OutPacket(kupack, ThrottleOutPacketType.Task);
+                // You must sleep here or users get no message!
+                Thread.Sleep(500);
+            }
+        }
+
+        public void Stop()
+        {
+
+        }
+
+        #endregion Client Methods
+
+        #region Packet Handling
+
+        public void PopulateStats(int inPackets, int outPackets, int unAckedBytes)
+        {
+            NetworkStats handlerNetworkStatsUpdate = OnNetworkStatsUpdate;
+            if (handlerNetworkStatsUpdate != null)
+            {
+                handlerNetworkStatsUpdate(inPackets, outPackets, unAckedBytes);
+            }
+        }
+
+        public static bool AddPacketHandler(PacketType packetType, PacketMethod handler)
+        {
+            bool result = false;
+            lock (PacketHandlers)
+            {
+                if (!PacketHandlers.ContainsKey(packetType))
+                {
+                    PacketHandlers.Add(packetType, handler);
+                    result = true;
+                }
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Add a handler for the given packet type.
+        /// </summary>
+        /// <remarks>
+        /// The packet is handled on its own thread.  If packets must be handled in the order in which they
+        /// are received then please use the synchronous version of this method.
+        /// </remarks>
+        /// <param name="packetType"></param>
+        /// <param name="handler"></param>
+        /// <returns>true if the handler was added.  This is currently always the case.</returns>
+        public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler)
+        {
+            return AddLocalPacketHandler(packetType, handler, true);
+        }
+
+        /// <summary>
+        /// Add a handler for the given packet type.
+        /// </summary>
+        /// <param name="packetType"></param>
+        /// <param name="handler"></param>
+        /// <param name="doAsync">
+        /// If true, when the packet is received it is handled on its own thread rather than on the main inward bound
+        /// packet handler thread.  This vastly increases respnosiveness but some packets need to be handled
+        /// synchronously.
+        /// </param>
+        /// <returns>true if the handler was added.  This is currently always the case.</returns>
+        public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler, bool doAsync)
+        {
+            bool result = false;
+            lock (m_packetHandlers)
+            {
+                if (!m_packetHandlers.ContainsKey(packetType))
+                {
+                    m_packetHandlers.Add(
+                        packetType, new PacketProcessor() { method = handler, Async = doAsync});
+                    result = true;
+                }
+            }
+
+            return result;
+        }
+
+        public bool AddGenericPacketHandler(string MethodName, GenericMessage handler)
+        {
+            MethodName = MethodName.ToLower().Trim();
+
+            bool result = false;
+            lock (m_genericPacketHandlers)
+            {
+                if (!m_genericPacketHandlers.ContainsKey(MethodName))
+                {
+                    m_genericPacketHandlers.Add(MethodName, handler);
+                    result = true;
+                }
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Try to process a packet using registered packet handlers
+        /// </summary>
+        /// <param name="packet"></param>
+        /// <returns>True if a handler was found which successfully processed the packet.</returns>
+        protected virtual bool ProcessPacketMethod(Packet packet)
+        {
+            bool result = false;
+            PacketProcessor pprocessor;
+            if (m_packetHandlers.TryGetValue(packet.Type, out pprocessor))
+            {
+
+                //there is a local handler for this packet type
+                if (pprocessor.Async)
+                {
+                    object obj = new AsyncPacketProcess(this, pprocessor.method, packet);
+                    m_asyncPacketProcess.QueueJob(packet.Type.ToString(), () => ProcessSpecificPacketAsync(obj));
+                    result = true;
+                }
+                else
+                {
+                    result = pprocessor.method(this, packet);
+                }
+            }
+            else
+            {
+                //there is not a local handler so see if there is a Global handler
+                PacketMethod method = null;
+                bool found;
+                lock (PacketHandlers)
+                {
+                    found = PacketHandlers.TryGetValue(packet.Type, out method);
+                }
+                if (found)
+                {
+                    result = method(this, packet);
+                }
+            }
+            return result;
+        }
+
+        public void ProcessSpecificPacketAsync(object state)
+        {
+            AsyncPacketProcess packetObject = (AsyncPacketProcess)state;
+
+            try
+            {
+                packetObject.result = packetObject.Method(packetObject.ClientView, packetObject.Pack);
+            }
+            catch (Exception e)
+            {
+                // Make sure that we see any exception caused by the asynchronous operation.
+                m_log.Error(
+                    string.Format(
+                        "[LLCLIENTVIEW]: Caught exception while processing {0} for {1}  ", packetObject.Pack, Name),
+                    e);
+            }
+        }
+
+        #endregion Packet Handling
+
+        # region Setup
+
+        public virtual void Start()
+        {
+            m_asyncPacketProcess.Start();
+            m_scene.AddNewAgent(this, PresenceType.User);
+
+//            RefreshGroupMembership();
+        }
+
+        # endregion
+
+        public void ActivateGesture(UUID assetId, UUID gestureId)
+        {
+        }
+
+        public void DeactivateGesture(UUID assetId, UUID gestureId)
+        {
+        }
+
+        // Sound
+        public void SoundTrigger(UUID soundId, UUID owerid, UUID Objectid, UUID ParentId, float Gain, Vector3 Position, UInt64 Handle)
+        {
+        }
+
+        #region Scene/Avatar to Client
+
+        public void SendRegionHandshake(RegionInfo regionInfo, RegionHandshakeArgs args)
+        {
+            RegionHandshakePacket handshake = (RegionHandshakePacket)PacketPool.Instance.GetPacket(PacketType.RegionHandshake);
+            handshake.RegionInfo = new RegionHandshakePacket.RegionInfoBlock();
+            handshake.RegionInfo.BillableFactor = args.billableFactor;
+            handshake.RegionInfo.IsEstateManager = args.isEstateManager;
+            handshake.RegionInfo.TerrainHeightRange00 = args.terrainHeightRange0;
+            handshake.RegionInfo.TerrainHeightRange01 = args.terrainHeightRange1;
+            handshake.RegionInfo.TerrainHeightRange10 = args.terrainHeightRange2;
+            handshake.RegionInfo.TerrainHeightRange11 = args.terrainHeightRange3;
+            handshake.RegionInfo.TerrainStartHeight00 = args.terrainStartHeight0;
+            handshake.RegionInfo.TerrainStartHeight01 = args.terrainStartHeight1;
+            handshake.RegionInfo.TerrainStartHeight10 = args.terrainStartHeight2;
+            handshake.RegionInfo.TerrainStartHeight11 = args.terrainStartHeight3;
+            handshake.RegionInfo.SimAccess = args.simAccess;
+            handshake.RegionInfo.WaterHeight = args.waterHeight;
+
+            handshake.RegionInfo.RegionFlags = args.regionFlags;
+            handshake.RegionInfo.SimName = Util.StringToBytes256(args.regionName);
+            handshake.RegionInfo.SimOwner = args.SimOwner;
+            handshake.RegionInfo.TerrainBase0 = args.terrainBase0;
+            handshake.RegionInfo.TerrainBase1 = args.terrainBase1;
+            handshake.RegionInfo.TerrainBase2 = args.terrainBase2;
+            handshake.RegionInfo.TerrainBase3 = args.terrainBase3;
+            handshake.RegionInfo.TerrainDetail0 = args.terrainDetail0;
+            handshake.RegionInfo.TerrainDetail1 = args.terrainDetail1;
+            handshake.RegionInfo.TerrainDetail2 = args.terrainDetail2;
+            handshake.RegionInfo.TerrainDetail3 = args.terrainDetail3;
+            handshake.RegionInfo.CacheID = UUID.Random(); //I guess this is for the client to remember an old setting?
+            handshake.RegionInfo2 = new RegionHandshakePacket.RegionInfo2Block();
+            handshake.RegionInfo2.RegionID = regionInfo.RegionID;
+
+            handshake.RegionInfo3 = new RegionHandshakePacket.RegionInfo3Block();
+            handshake.RegionInfo3.CPUClassID = 9;
+            handshake.RegionInfo3.CPURatio = 1;
+
+            handshake.RegionInfo3.ColoName = Utils.EmptyBytes;
+            handshake.RegionInfo3.ProductName = Util.StringToBytes256(regionInfo.RegionType);
+            handshake.RegionInfo3.ProductSKU = Utils.EmptyBytes;
+
+            handshake.RegionInfo4 = new RegionHandshakePacket.RegionInfo4Block[1];
+            handshake.RegionInfo4[0] = new RegionHandshakePacket.RegionInfo4Block();
+            handshake.RegionInfo4[0].RegionFlagsExtended = args.regionFlags;
+            handshake.RegionInfo4[0].RegionProtocols = 0; // 1 here would indicate that SSB is supported
+
+            OutPacket(handshake, ThrottleOutPacketType.Unknown);
+        }
+
+
+        public void MoveAgentIntoRegion(RegionInfo regInfo, Vector3 pos, Vector3 look)
+        {
+            m_thisAgentUpdateArgs.CameraAtAxis.X = float.MinValue;
+//            m_thisAgentUpdateArgs.ControlFlags = uint.MaxValue;
+            m_thisAgentUpdateArgs.ControlFlags = 0;
+
+            AgentMovementCompletePacket mov = (AgentMovementCompletePacket)PacketPool.Instance.GetPacket(PacketType.AgentMovementComplete);
+            mov.SimData.ChannelVersion = m_channelVersion;
+            mov.AgentData.SessionID = m_sessionId;
+            mov.AgentData.AgentID = AgentId;
+            mov.Data.RegionHandle = regInfo.RegionHandle;
+            mov.Data.Timestamp = (uint)Util.UnixTimeSinceEpoch();
+
+            if ((pos.X == 0) && (pos.Y == 0) && (pos.Z == 0))
+            {
+                mov.Data.Position = m_startpos;
+            }
+            else
+            {
+                mov.Data.Position = pos;
+            }
+            mov.Data.LookAt = look;
+
+            // Hack to get this out immediately and skip the throttles
+            OutPacket(mov, ThrottleOutPacketType.Unknown);
+        }
+
+        public void SendChatMessage(
+            string message, byte type, Vector3 fromPos, string fromName,
+            UUID fromAgentID, UUID ownerID, byte source, byte audible)
+        {
+            ChatFromSimulatorPacket reply = (ChatFromSimulatorPacket)PacketPool.Instance.GetPacket(PacketType.ChatFromSimulator);
+            reply.ChatData.Audible = audible;
+            reply.ChatData.Message = Util.StringToBytes1024(message);
+            reply.ChatData.ChatType = type;
+            reply.ChatData.SourceType = source;
+            reply.ChatData.Position = fromPos;
+            reply.ChatData.FromName = Util.StringToBytes256(fromName);
+            reply.ChatData.OwnerID = ownerID;
+            reply.ChatData.SourceID = fromAgentID;
+
+            OutPacket(reply, ThrottleOutPacketType.Unknown);
+        }
+
+        /// <summary>
+        /// Send an instant message to this client
+        /// </summary>
+        //
+        public void SendInstantMessage(GridInstantMessage im)
+        {
+            if (((Scene)(m_scene)).Permissions.CanInstantMessage(new UUID(im.fromAgentID), new UUID(im.toAgentID)))
+            {
+                ImprovedInstantMessagePacket msg
+                    = (ImprovedInstantMessagePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedInstantMessage);
+
+                msg.AgentData.AgentID = new UUID(im.fromAgentID);
+                msg.AgentData.SessionID = UUID.Zero;
+                msg.MessageBlock.FromAgentName = Util.StringToBytes256(im.fromAgentName);
+                msg.MessageBlock.Dialog = im.dialog;
+                msg.MessageBlock.FromGroup = im.fromGroup;
+                // this is odd
+                if (im.imSessionID == UUID.Zero.Guid)
+                    msg.MessageBlock.ID = new UUID(im.fromAgentID) ^ new UUID(im.toAgentID);
+                else
+                    msg.MessageBlock.ID = new UUID(im.imSessionID);
+                msg.MessageBlock.Offline = im.offline;
+                msg.MessageBlock.ParentEstateID = im.ParentEstateID;
+                msg.MessageBlock.Position = im.Position;
+                msg.MessageBlock.RegionID = new UUID(im.RegionID);
+                msg.MessageBlock.Timestamp = im.timestamp;
+                msg.MessageBlock.ToAgentID = new UUID(im.toAgentID);
+                msg.MessageBlock.Message = Util.StringToBytes1024(im.message);
+                msg.MessageBlock.BinaryBucket = im.binaryBucket;
+
+                OutPacket(msg, ThrottleOutPacketType.Task);
+            }
+        }
+
+        public void SendGenericMessage(string method, UUID invoice, List<string> message)
+        {
+            GenericMessagePacket gmp = new GenericMessagePacket();
+
+            gmp.AgentData.AgentID = AgentId;
+            gmp.AgentData.SessionID = m_sessionId;
+            gmp.AgentData.TransactionID = invoice;
+
+            gmp.MethodData.Method = Util.StringToBytes256(method);
+            gmp.ParamList = new GenericMessagePacket.ParamListBlock[message.Count];
+            int i = 0;
+            foreach (string val in message)
+            {
+                gmp.ParamList[i] = new GenericMessagePacket.ParamListBlock();
+                gmp.ParamList[i++].Parameter = Util.StringToBytes256(val);
+            }
+
+            OutPacket(gmp, ThrottleOutPacketType.Task);
+        }
+
+        public void SendGenericMessage(string method, UUID invoice, List<byte[]> message)
+        {
+            GenericMessagePacket gmp = new GenericMessagePacket();
+
+            gmp.AgentData.AgentID = AgentId;
+            gmp.AgentData.SessionID = m_sessionId;
+            gmp.AgentData.TransactionID = invoice;
+
+            gmp.MethodData.Method = Util.StringToBytes256(method);
+            gmp.ParamList = new GenericMessagePacket.ParamListBlock[message.Count];
+            int i = 0;
+            foreach (byte[] val in message)
+            {
+                gmp.ParamList[i] = new GenericMessagePacket.ParamListBlock();
+                gmp.ParamList[i++].Parameter = val;
+            }
+
+            OutPacket(gmp, ThrottleOutPacketType.Task);
+        }
+
+        public void SendGroupActiveProposals(UUID groupID, UUID transactionID, GroupActiveProposals[] Proposals)
+        {
+            int i = 0;
+            foreach (GroupActiveProposals Proposal in Proposals)
+            {
+                GroupActiveProposalItemReplyPacket GAPIRP = new GroupActiveProposalItemReplyPacket();
+
+                GAPIRP.AgentData.AgentID = AgentId;
+                GAPIRP.AgentData.GroupID = groupID;
+                GAPIRP.TransactionData.TransactionID = transactionID;
+                GAPIRP.TransactionData.TotalNumItems = ((uint)i+1);
+                GroupActiveProposalItemReplyPacket.ProposalDataBlock ProposalData = new GroupActiveProposalItemReplyPacket.ProposalDataBlock();
+                GAPIRP.ProposalData = new GroupActiveProposalItemReplyPacket.ProposalDataBlock[1];
+                ProposalData.VoteCast = Utils.StringToBytes("false");
+                ProposalData.VoteID = new UUID(Proposal.VoteID);
+                ProposalData.VoteInitiator = new UUID(Proposal.VoteInitiator);
+                ProposalData.Majority = (float)Convert.ToInt32(Proposal.Majority);
+                ProposalData.Quorum = Convert.ToInt32(Proposal.Quorum);
+                ProposalData.TerseDateID = Utils.StringToBytes(Proposal.TerseDateID);
+                ProposalData.StartDateTime = Utils.StringToBytes(Proposal.StartDateTime);
+                ProposalData.EndDateTime = Utils.StringToBytes(Proposal.EndDateTime);
+                ProposalData.ProposalText = Utils.StringToBytes(Proposal.ProposalText);
+                ProposalData.AlreadyVoted = false;
+                GAPIRP.ProposalData[i] = ProposalData;
+                OutPacket(GAPIRP, ThrottleOutPacketType.Task);
+                i++;
+            }
+            if (Proposals.Length == 0)
+            {
+                GroupActiveProposalItemReplyPacket GAPIRP = new GroupActiveProposalItemReplyPacket();
+
+                GAPIRP.AgentData.AgentID = AgentId;
+                GAPIRP.AgentData.GroupID = groupID;
+                GAPIRP.TransactionData.TransactionID = transactionID;
+                GAPIRP.TransactionData.TotalNumItems = 1;
+                GroupActiveProposalItemReplyPacket.ProposalDataBlock ProposalData = new GroupActiveProposalItemReplyPacket.ProposalDataBlock();
+                GAPIRP.ProposalData = new GroupActiveProposalItemReplyPacket.ProposalDataBlock[1];
+                ProposalData.VoteCast = Utils.StringToBytes("false");
+                ProposalData.VoteID = UUID.Zero;
+                ProposalData.VoteInitiator = UUID.Zero;
+                ProposalData.Majority = 0;
+                ProposalData.Quorum = 0;
+                ProposalData.TerseDateID = Utils.StringToBytes("");
+                ProposalData.StartDateTime = Utils.StringToBytes("");
+                ProposalData.EndDateTime = Utils.StringToBytes("");
+                ProposalData.ProposalText = Utils.StringToBytes("");
+                ProposalData.AlreadyVoted = false;
+                GAPIRP.ProposalData[0] = ProposalData;
+                OutPacket(GAPIRP, ThrottleOutPacketType.Task);
+            }
+        }
+
+        public void SendGroupVoteHistory(UUID groupID, UUID transactionID, GroupVoteHistory[] Votes)
+        {
+            int i = 0;
+            foreach (GroupVoteHistory Vote in Votes)
+            {
+                GroupVoteHistoryItemReplyPacket GVHIRP = new GroupVoteHistoryItemReplyPacket();
+
+                GVHIRP.AgentData.AgentID = AgentId;
+                GVHIRP.AgentData.GroupID = groupID;
+                GVHIRP.TransactionData.TransactionID = transactionID;
+                GVHIRP.TransactionData.TotalNumItems = ((uint)i+1);
+                GVHIRP.HistoryItemData.VoteID = new UUID(Vote.VoteID);
+                GVHIRP.HistoryItemData.VoteInitiator = new UUID(Vote.VoteInitiator);
+                GVHIRP.HistoryItemData.Majority = (float)Convert.ToInt32(Vote.Majority);
+                GVHIRP.HistoryItemData.Quorum = Convert.ToInt32(Vote.Quorum);
+                GVHIRP.HistoryItemData.TerseDateID = Utils.StringToBytes(Vote.TerseDateID);
+                GVHIRP.HistoryItemData.StartDateTime = Utils.StringToBytes(Vote.StartDateTime);
+                GVHIRP.HistoryItemData.EndDateTime = Utils.StringToBytes(Vote.EndDateTime);
+                GVHIRP.HistoryItemData.VoteType = Utils.StringToBytes(Vote.VoteType);
+                GVHIRP.HistoryItemData.VoteResult = Utils.StringToBytes(Vote.VoteResult);
+                GVHIRP.HistoryItemData.ProposalText = Utils.StringToBytes(Vote.ProposalText);
+                GroupVoteHistoryItemReplyPacket.VoteItemBlock VoteItem = new GroupVoteHistoryItemReplyPacket.VoteItemBlock();
+                GVHIRP.VoteItem = new GroupVoteHistoryItemReplyPacket.VoteItemBlock[1];
+                VoteItem.CandidateID = UUID.Zero;
+                VoteItem.NumVotes = 0; //TODO: FIX THIS!!!
+                VoteItem.VoteCast = Utils.StringToBytes("Yes");
+                GVHIRP.VoteItem[i] = VoteItem;
+                OutPacket(GVHIRP, ThrottleOutPacketType.Task);
+                i++;
+            }
+            if (Votes.Length == 0)
+            {
+                GroupVoteHistoryItemReplyPacket GVHIRP = new GroupVoteHistoryItemReplyPacket();
+
+                GVHIRP.AgentData.AgentID = AgentId;
+                GVHIRP.AgentData.GroupID = groupID;
+                GVHIRP.TransactionData.TransactionID = transactionID;
+                GVHIRP.TransactionData.TotalNumItems = 0;
+                GVHIRP.HistoryItemData.VoteID = UUID.Zero;
+                GVHIRP.HistoryItemData.VoteInitiator = UUID.Zero;
+                GVHIRP.HistoryItemData.Majority = 0;
+                GVHIRP.HistoryItemData.Quorum = 0;
+                GVHIRP.HistoryItemData.TerseDateID = Utils.StringToBytes("");
+                GVHIRP.HistoryItemData.StartDateTime = Utils.StringToBytes("");
+                GVHIRP.HistoryItemData.EndDateTime = Utils.StringToBytes("");
+                GVHIRP.HistoryItemData.VoteType = Utils.StringToBytes("");
+                GVHIRP.HistoryItemData.VoteResult = Utils.StringToBytes("");
+                GVHIRP.HistoryItemData.ProposalText = Utils.StringToBytes("");
+                GroupVoteHistoryItemReplyPacket.VoteItemBlock VoteItem = new GroupVoteHistoryItemReplyPacket.VoteItemBlock();
+                GVHIRP.VoteItem = new GroupVoteHistoryItemReplyPacket.VoteItemBlock[1];
+                VoteItem.CandidateID = UUID.Zero;
+                VoteItem.NumVotes = 0; //TODO: FIX THIS!!!
+                VoteItem.VoteCast = Utils.StringToBytes("No");
+                GVHIRP.VoteItem[0] = VoteItem;
+                OutPacket(GVHIRP, ThrottleOutPacketType.Task);
+            }
+        }
+
+        public void SendGroupAccountingDetails(IClientAPI sender,UUID groupID, UUID transactionID, UUID sessionID, int amt)
+        {
+            GroupAccountDetailsReplyPacket GADRP = new GroupAccountDetailsReplyPacket();
+            GADRP.AgentData = new GroupAccountDetailsReplyPacket.AgentDataBlock();
+            GADRP.AgentData.AgentID = sender.AgentId;
+            GADRP.AgentData.GroupID = groupID;
+            GADRP.HistoryData = new GroupAccountDetailsReplyPacket.HistoryDataBlock[1];
+            GroupAccountDetailsReplyPacket.HistoryDataBlock History = new GroupAccountDetailsReplyPacket.HistoryDataBlock();
+            GADRP.MoneyData = new GroupAccountDetailsReplyPacket.MoneyDataBlock();
+            GADRP.MoneyData.CurrentInterval = 0;
+            GADRP.MoneyData.IntervalDays = 7;
+            GADRP.MoneyData.RequestID = transactionID;
+            GADRP.MoneyData.StartDate = Utils.StringToBytes(DateTime.Today.ToString());
+            History.Amount = amt;
+            History.Description = Utils.StringToBytes("");
+            GADRP.HistoryData[0] = History;
+            OutPacket(GADRP, ThrottleOutPacketType.Task);
+        }
+
+        public void SendGroupAccountingSummary(IClientAPI sender,UUID groupID, uint moneyAmt, int totalTier, int usedTier)
+        {
+            GroupAccountSummaryReplyPacket GASRP =
+                    (GroupAccountSummaryReplyPacket)PacketPool.Instance.GetPacket(
+                    PacketType.GroupAccountSummaryReply);
+
+            GASRP.AgentData = new GroupAccountSummaryReplyPacket.AgentDataBlock();
+            GASRP.AgentData.AgentID = sender.AgentId;
+            GASRP.AgentData.GroupID = groupID;
+            GASRP.MoneyData = new GroupAccountSummaryReplyPacket.MoneyDataBlock();
+            GASRP.MoneyData.Balance = (int)moneyAmt;
+            GASRP.MoneyData.TotalCredits = totalTier;
+            GASRP.MoneyData.TotalDebits = usedTier;
+            GASRP.MoneyData.StartDate = new byte[1];
+            GASRP.MoneyData.CurrentInterval = 1;
+            GASRP.MoneyData.GroupTaxCurrent = 0;
+            GASRP.MoneyData.GroupTaxEstimate = 0;
+            GASRP.MoneyData.IntervalDays = 0;
+            GASRP.MoneyData.LandTaxCurrent = 0;
+            GASRP.MoneyData.LandTaxEstimate = 0;
+            GASRP.MoneyData.LastTaxDate = new byte[1];
+            GASRP.MoneyData.LightTaxCurrent = 0;
+            GASRP.MoneyData.TaxDate = new byte[1];
+            GASRP.MoneyData.RequestID = sender.AgentId;
+            GASRP.MoneyData.ParcelDirFeeEstimate = 0;
+            GASRP.MoneyData.ParcelDirFeeCurrent = 0;
+            GASRP.MoneyData.ObjectTaxEstimate = 0;
+            GASRP.MoneyData.NonExemptMembers = 0;
+            GASRP.MoneyData.ObjectTaxCurrent = 0;
+            GASRP.MoneyData.LightTaxEstimate = 0;
+            OutPacket(GASRP, ThrottleOutPacketType.Task);
+        }
+
+        public void SendGroupTransactionsSummaryDetails(IClientAPI sender,UUID groupID, UUID transactionID, UUID sessionID, int amt)
+        {
+            GroupAccountTransactionsReplyPacket GATRP =
+                    (GroupAccountTransactionsReplyPacket)PacketPool.Instance.GetPacket(
+                    PacketType.GroupAccountTransactionsReply);
+
+            GATRP.AgentData = new GroupAccountTransactionsReplyPacket.AgentDataBlock();
+            GATRP.AgentData.AgentID = sender.AgentId;
+            GATRP.AgentData.GroupID = groupID;
+            GATRP.MoneyData = new GroupAccountTransactionsReplyPacket.MoneyDataBlock();
+            GATRP.MoneyData.CurrentInterval = 0;
+            GATRP.MoneyData.IntervalDays = 7;
+            GATRP.MoneyData.RequestID = transactionID;
+            GATRP.MoneyData.StartDate = Utils.StringToBytes(DateTime.Today.ToString());
+            GATRP.HistoryData = new GroupAccountTransactionsReplyPacket.HistoryDataBlock[1];
+            GroupAccountTransactionsReplyPacket.HistoryDataBlock History = new GroupAccountTransactionsReplyPacket.HistoryDataBlock();
+            History.Amount = 0;
+            History.Item = Utils.StringToBytes("");
+            History.Time = Utils.StringToBytes("");
+            History.Type = 0;
+            History.User = Utils.StringToBytes("");
+            GATRP.HistoryData[0] = History;
+            OutPacket(GATRP, ThrottleOutPacketType.Task);
+        }
+
+
+        public virtual bool CanSendLayerData()
+        {
+            int n = m_udpClient.GetPacketsQueuedCount(ThrottleOutPacketType.Land);
+            if ( n > 128)
+                return false;
+            return true;
+        }
+
+        /// <summary>
+        ///  Send the region heightmap to the client
+        ///  This method is only called when not doing intellegent terrain patch sending and
+        ///  is only called when the scene presence is initially created and sends all of the
+        ///  region's patches to the client.
+        /// </summary>
+        /// <param name="map">heightmap</param>
+        public virtual void SendLayerData(float[] map)
+        {
+            Util.FireAndForget(DoSendLayerData, m_scene.Heightmap.GetTerrainData(), "LLClientView.DoSendLayerData");
+
+            // Send it sync, and async. It's not that much data
+            // and it improves user experience just so much!
+//            DoSendLayerData(map);
+        }
+
+        /// <summary>
+        /// Send terrain layer information to the client.
+        /// </summary>
+        /// <param name="o"></param>
+        private void DoSendLayerData(object o)
+        {
+            TerrainData map = (TerrainData)o;
+
+            try
+            {
+                // Send LayerData in typerwriter pattern
+                //for (int y = 0; y < 16; y++)
+                //{
+                //    for (int x = 0; x < 16; x++)
+                //    {
+                //        SendLayerData(x, y, map);
+                //    }
+                //}
+
+                // Send LayerData in a spiral pattern. Fun!
+                SendLayerTopRight(map, 0, 0, map.SizeX / Constants.TerrainPatchSize - 1, map.SizeY / Constants.TerrainPatchSize - 1);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CLIENT]: SendLayerData() Failed with exception: " + e.Message, e);
+            }
+        }
+
+        private void SendLayerTopRight(TerrainData map, int x1, int y1, int x2, int y2)
+        {
+            // Row
+            for (int i = x1; i <= x2; i++)
+                SendLayerData(i, y1, map);
+
+            // Column
+            for (int j = y1 + 1; j <= y2; j++)
+                SendLayerData(x2, j, map);
+
+            if (x2 - x1 > 0 && y2 - y1 > 0)
+                SendLayerBottomLeft(map, x1, y1 + 1, x2 - 1, y2);
+        }
+
+        void SendLayerBottomLeft(TerrainData map, int x1, int y1, int x2, int y2)
+        {
+            // Row in reverse
+            for (int i = x2; i >= x1; i--)
+                SendLayerData(i, y2, map);
+
+            // Column in reverse
+            for (int j = y2 - 1; j >= y1; j--)
+                SendLayerData(x1, j, map);
+
+            if (x2 - x1 > 0 && y2 - y1 > 0)
+                SendLayerTopRight(map, x1 + 1, y1, x2, y2 - 1);
+        }
+
+
+        // Legacy form of invocation that passes around a bare data array.
+        // Just ignore what was passed and use the real terrain info that is part of the scene.
+        // As a HORRIBLE kludge in an attempt to not change the definition of IClientAPI,
+        //    there is a special form for specifying multiple terrain patches to send.
+        //    The form is to pass 'px' as negative the number of patches to send and to
+        //    pass the float array as pairs of patch X and Y coordinates. So, passing 'px'
+        //    as -2 and map= [3, 5, 8, 4] would mean to send two terrain heightmap patches
+        //    and the patches to send are <3,5> and <8,4>.
+        public void SendLayerData(int px, int py, float[] map)
+        {
+            if (px >= 0)
+            {
+                SendLayerData(px, py, m_scene.Heightmap.GetTerrainData());
+            }
+            else
+            {
+                int numPatches = -px;
+                int[] xPatches = new int[numPatches];
+                int[] yPatches = new int[numPatches];
+                for (int pp = 0; pp < numPatches; pp++)
+                {
+                    xPatches[pp] = (int)map[pp * 2];
+                    yPatches[pp] = (int)map[pp * 2 + 1];
+                }
+
+                // DebugSendingPatches("SendLayerData", xPatches, yPatches);
+
+                SendLayerData(xPatches, yPatches, m_scene.Heightmap.GetTerrainData());
+            }
+        }
+
+        private void DebugSendingPatches(string pWho, int[] pX, int[] pY)
+        {
+            if (m_log.IsDebugEnabled)
+            {
+                int numPatches = pX.Length;
+                string Xs = "";
+                string Ys = "";
+                for (int pp = 0; pp < numPatches; pp++)
+                {
+                    Xs += String.Format("{0}", (int)pX[pp]) + ",";
+                    Ys += String.Format("{0}", (int)pY[pp]) + ",";
+                }
+                m_log.DebugFormat("{0} {1}: numPatches={2}, X={3}, Y={4}", LogHeader, pWho, numPatches, Xs, Ys);
+            }
+        }
+
+        /// <summary>
+
+        /// Sends a terrain packet for the point specified.
+        /// This is a legacy call that has refarbed the terrain into a flat map of floats.
+        /// We just use the terrain from the region we know about.
+        /// </summary>
+        /// <param name="px">Patch coordinate (x) 0..15</param>
+        /// <param name="py">Patch coordinate (y) 0..15</param>
+        /// <param name="map">heightmap</param>
+        public void SendLayerData(int px, int py, TerrainData terrData)
+        {
+            int[] xPatches = new[] { px };
+            int[] yPatches = new[] { py };
+            SendLayerData(xPatches, yPatches, terrData);
+        }
+
+        private void SendLayerData(int[] px, int[] py, TerrainData terrData)
+        {
+            try
+            {
+                byte landPacketType;
+                if (terrData.SizeX > Constants.RegionSize || terrData.SizeY > Constants.RegionSize)
+                    landPacketType = (byte)TerrainPatch.LayerType.LandExtended;
+                else
+                    landPacketType = (byte)TerrainPatch.LayerType.Land;
+
+                List<LayerDataPacket> packets = OpenSimTerrainCompressor.CreateLayerDataPackets(terrData, px, py, landPacketType);
+                foreach(LayerDataPacket pkt in packets)
+                    OutPacket(pkt, ThrottleOutPacketType.Land);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CLIENT]: SendLayerData() Failed with exception: " + e.Message, e);
+            }
+        }
+
+
+        // wind caching
+        private static Dictionary<ulong,int> lastWindVersion = new Dictionary<ulong,int>();
+        private static Dictionary<ulong,List<LayerDataPacket>> lastWindPackets =
+                 new Dictionary<ulong,List<LayerDataPacket>>();
+
+
+        /// <summary>
+        ///  Send the wind matrix to the client
+        /// </summary>
+        /// <param name="windSpeeds">16x16 array of wind speeds</param>
+        public virtual void SendWindData(int version, Vector2[] windSpeeds)
+        {
+//            Vector2[] windSpeeds = (Vector2[])o;
+
+            ulong handle = this.Scene.RegionInfo.RegionHandle;
+            bool isNewData;
+            lock(lastWindPackets)
+            {
+                if(!lastWindVersion.ContainsKey(handle) ||
+                    !lastWindPackets.ContainsKey(handle))
+                {
+                    lastWindVersion[handle] = 0;
+                    lastWindPackets[handle] = new List<LayerDataPacket>();
+                    isNewData = true;
+                }
+                else
+                    isNewData = lastWindVersion[handle] != version;
+            }
+
+            if(isNewData)
+            {
+                TerrainPatch[] patches = new TerrainPatch[2];
+                patches[0] = new TerrainPatch { Data = new float[16 * 16] };
+                patches[1] = new TerrainPatch { Data = new float[16 * 16] };
+
+                for (int x = 0; x < 16 * 16; x++)
+                {
+                    patches[0].Data[x] = windSpeeds[x].X;
+                    patches[1].Data[x] = windSpeeds[x].Y;
+                }
+
+                // neither we or viewers have extended wind
+                byte layerType = (byte)TerrainPatch.LayerType.Wind;
+
+                LayerDataPacket layerpack =
+                     OpenSimTerrainCompressor.CreateLayerDataPacketStandardSize(
+                        patches, layerType);
+                layerpack.Header.Zerocoded = true;
+                lock(lastWindPackets)
+                {
+                    lastWindPackets[handle].Clear();
+                    lastWindPackets[handle].Add(layerpack);
+                    lastWindVersion[handle] = version;
+                }
+            }
+
+            lock(lastWindPackets)
+                foreach(LayerDataPacket pkt in lastWindPackets[handle])
+                    OutPacket(pkt, ThrottleOutPacketType.Wind);
+        }
+
+        // cloud caching
+        private static Dictionary<ulong,int> lastCloudVersion = new Dictionary<ulong,int>();
+        private static Dictionary<ulong,List<LayerDataPacket>> lastCloudPackets =
+                 new Dictionary<ulong,List<LayerDataPacket>>();
+
+        /// <summary>
+        ///  Send the cloud matrix to the client
+        /// </summary>
+        /// <param name="windSpeeds">16x16 array of cloud densities</param>
+        public virtual void SendCloudData(int version, float[] cloudDensity)
+        {
+            ulong handle = this.Scene.RegionInfo.RegionHandle;
+            bool isNewData;
+            lock(lastWindPackets)
+            {
+                if(!lastCloudVersion.ContainsKey(handle) ||
+                    !lastCloudPackets.ContainsKey(handle))
+                {
+                    lastCloudVersion[handle] = 0;
+                    lastCloudPackets[handle] = new List<LayerDataPacket>();
+                    isNewData = true;
+                }
+                else
+                    isNewData = lastCloudVersion[handle] != version;
+            }
+
+            if(isNewData)
+            {
+                TerrainPatch[] patches = new TerrainPatch[1];
+                patches[0] = new TerrainPatch();
+                patches[0].Data = new float[16 * 16];
+
+                for (int y = 0; y < 16; y++)
+                {
+                    for (int x = 0; x < 16; x++)
+                    {
+                        patches[0].Data[y * 16 + x] = cloudDensity[y * 16 + x];
+                    }
+                }
+                // neither we or viewers have extended clouds
+                byte layerType = (byte)TerrainPatch.LayerType.Cloud;
+
+                LayerDataPacket layerpack =
+                    OpenSimTerrainCompressor.CreateLayerDataPacketStandardSize(
+                        patches, layerType);
+                layerpack.Header.Zerocoded = true;
+                lock(lastCloudPackets)
+                {
+                    lastCloudPackets[handle].Clear();
+                    lastCloudPackets[handle].Add(layerpack);
+                    lastCloudVersion[handle] = version;
+                }
+            }
+
+            lock(lastCloudPackets)
+                foreach(LayerDataPacket pkt in lastCloudPackets[handle])
+                    OutPacket(pkt, ThrottleOutPacketType.Cloud);
+        }
+
+        /// <summary>
+        /// Tell the client that the given neighbour region is ready to receive a child agent.
+        /// </summary>
+        public virtual void InformClientOfNeighbour(ulong neighbourHandle, IPEndPoint neighbourEndPoint)
+        {
+            IPAddress neighbourIP = neighbourEndPoint.Address;
+            ushort neighbourPort = (ushort)neighbourEndPoint.Port;
+
+            EnableSimulatorPacket enablesimpacket = (EnableSimulatorPacket)PacketPool.Instance.GetPacket(PacketType.EnableSimulator);
+            // TODO: don't create new blocks if recycling an old packet
+            enablesimpacket.SimulatorInfo = new EnableSimulatorPacket.SimulatorInfoBlock();
+            enablesimpacket.SimulatorInfo.Handle = neighbourHandle;
+
+            byte[] byteIP = neighbourIP.GetAddressBytes();
+            enablesimpacket.SimulatorInfo.IP = (uint)byteIP[3] << 24;
+            enablesimpacket.SimulatorInfo.IP += (uint)byteIP[2] << 16;
+            enablesimpacket.SimulatorInfo.IP += (uint)byteIP[1] << 8;
+            enablesimpacket.SimulatorInfo.IP += (uint)byteIP[0];
+            enablesimpacket.SimulatorInfo.Port = neighbourPort;
+
+            enablesimpacket.Header.Reliable = true; // ESP's should be reliable.
+
+            OutPacket(enablesimpacket, ThrottleOutPacketType.Task);
+        }
+
+        public AgentCircuitData RequestClientInfo()
+        {
+            AgentCircuitData agentData = new AgentCircuitData();
+            agentData.AgentID = AgentId;
+            agentData.SessionID = m_sessionId;
+            agentData.SecureSessionID = SecureSessionId;
+            agentData.circuitcode = m_circuitCode;
+            agentData.child = false;
+            agentData.firstname = m_firstName;
+            agentData.lastname = m_lastName;
+
+            ICapabilitiesModule capsModule = m_scene.RequestModuleInterface<ICapabilitiesModule>();
+
+            if (capsModule == null) // can happen when shutting down.
+                return agentData;
+
+            agentData.CapsPath = capsModule.GetCapsPath(m_agentId);
+            agentData.ChildrenCapSeeds = new Dictionary<ulong, string>(capsModule.GetChildrenSeeds(m_agentId));
+
+            return agentData;
+        }
+
+        public virtual void CrossRegion(ulong newRegionHandle, Vector3 pos, Vector3 lookAt, IPEndPoint externalIPEndPoint,
+                                string capsURL)
+        {
+            Vector3 look = new Vector3(lookAt.X * 10, lookAt.Y * 10, lookAt.Z * 10);
+
+            //CrossedRegionPacket newSimPack = (CrossedRegionPacket)PacketPool.Instance.GetPacket(PacketType.CrossedRegion);
+            CrossedRegionPacket newSimPack = new CrossedRegionPacket();
+            // TODO: don't create new blocks if recycling an old packet
+            newSimPack.AgentData = new CrossedRegionPacket.AgentDataBlock();
+            newSimPack.AgentData.AgentID = AgentId;
+            newSimPack.AgentData.SessionID = m_sessionId;
+            newSimPack.Info = new CrossedRegionPacket.InfoBlock();
+            newSimPack.Info.Position = pos;
+            newSimPack.Info.LookAt = look;
+            newSimPack.RegionData = new CrossedRegionPacket.RegionDataBlock();
+            newSimPack.RegionData.RegionHandle = newRegionHandle;
+            byte[] byteIP = externalIPEndPoint.Address.GetAddressBytes();
+            newSimPack.RegionData.SimIP = (uint)byteIP[3] << 24;
+            newSimPack.RegionData.SimIP += (uint)byteIP[2] << 16;
+            newSimPack.RegionData.SimIP += (uint)byteIP[1] << 8;
+            newSimPack.RegionData.SimIP += (uint)byteIP[0];
+            newSimPack.RegionData.SimPort = (ushort)externalIPEndPoint.Port;
+            newSimPack.RegionData.SeedCapability = Util.StringToBytes256(capsURL);
+
+            // Hack to get this out immediately and skip throttles
+            OutPacket(newSimPack, ThrottleOutPacketType.Unknown);
+        }
+
+        internal void SendMapBlockSplit(List<MapBlockData> mapBlocks, uint flag)
+        {
+            MapBlockReplyPacket mapReply = (MapBlockReplyPacket)PacketPool.Instance.GetPacket(PacketType.MapBlockReply);
+            // TODO: don't create new blocks if recycling an old packet
+
+            MapBlockData[] mapBlocks2 = mapBlocks.ToArray();
+
+            mapReply.AgentData.AgentID = AgentId;
+            mapReply.Data = new MapBlockReplyPacket.DataBlock[mapBlocks2.Length];
+            mapReply.Size = new MapBlockReplyPacket.SizeBlock[mapBlocks2.Length];
+            mapReply.AgentData.Flags = flag;
+
+            for (int i = 0; i < mapBlocks2.Length; i++)
+            {
+                mapReply.Data[i] = new MapBlockReplyPacket.DataBlock();
+                mapReply.Data[i].MapImageID = mapBlocks2[i].MapImageId;
+                //m_log.Warn(mapBlocks2[i].MapImageId.ToString());
+                mapReply.Data[i].X = mapBlocks2[i].X;
+                mapReply.Data[i].Y = mapBlocks2[i].Y;
+                mapReply.Data[i].WaterHeight = mapBlocks2[i].WaterHeight;
+                mapReply.Data[i].Name = Utils.StringToBytes(mapBlocks2[i].Name);
+                mapReply.Data[i].RegionFlags = mapBlocks2[i].RegionFlags;
+                mapReply.Data[i].Access = mapBlocks2[i].Access;
+                mapReply.Data[i].Agents = mapBlocks2[i].Agents;
+
+                mapReply.Size[i] = new MapBlockReplyPacket.SizeBlock();
+                mapReply.Size[i].SizeX = mapBlocks2[i].SizeX;
+                mapReply.Size[i].SizeY = mapBlocks2[i].SizeY;
+            }
+            OutPacket(mapReply, ThrottleOutPacketType.Land);
+        }
+
+        public void SendMapBlock(List<MapBlockData> mapBlocks, uint flag)
+        {
+            MapBlockData[] mapBlocks2 = mapBlocks.ToArray();
+
+            int maxsend = 10;
+
+            //int packets = Math.Ceiling(mapBlocks2.Length / maxsend);
+
+            List<MapBlockData> sendingBlocks = new List<MapBlockData>();
+
+            for (int i = 0; i < mapBlocks2.Length; i++)
+            {
+                sendingBlocks.Add(mapBlocks2[i]);
+                if (((i + 1) == mapBlocks2.Length) || (((i + 1) % maxsend) == 0))
+                {
+                    SendMapBlockSplit(sendingBlocks, flag);
+                    sendingBlocks = new List<MapBlockData>();
+                }
+            }
+        }
+
+        public void SendLocalTeleport(Vector3 position, Vector3 lookAt, uint flags)
+        {
+            TeleportLocalPacket tpLocal = (TeleportLocalPacket)PacketPool.Instance.GetPacket(PacketType.TeleportLocal);
+            tpLocal.Info.AgentID = AgentId;
+            tpLocal.Info.TeleportFlags = flags;
+            tpLocal.Info.LocationID = 2;
+            tpLocal.Info.LookAt = lookAt;
+            tpLocal.Info.Position = position;
+
+            // Hack to get this out immediately and skip throttles
+            OutPacket(tpLocal, ThrottleOutPacketType.Unknown);
+        }
+
+        public virtual void SendRegionTeleport(ulong regionHandle, byte simAccess, IPEndPoint newRegionEndPoint, uint locationID,
+                                       uint flags, string capsURL)
+        {
+            //TeleportFinishPacket teleport = (TeleportFinishPacket)PacketPool.Instance.GetPacket(PacketType.TeleportFinish);
+
+            TeleportFinishPacket teleport = new TeleportFinishPacket();
+            teleport.Info.AgentID = AgentId;
+            teleport.Info.RegionHandle = regionHandle;
+            teleport.Info.SimAccess = simAccess;
+
+            teleport.Info.SeedCapability = Util.StringToBytes256(capsURL);
+
+            IPAddress oIP = newRegionEndPoint.Address;
+            byte[] byteIP = oIP.GetAddressBytes();
+            uint ip = (uint)byteIP[3] << 24;
+            ip += (uint)byteIP[2] << 16;
+            ip += (uint)byteIP[1] << 8;
+            ip += (uint)byteIP[0];
+
+            teleport.Info.SimIP = ip;
+            teleport.Info.SimPort = (ushort)newRegionEndPoint.Port;
+            teleport.Info.LocationID = 4;
+            teleport.Info.TeleportFlags = 1 << 4;
+
+            // Hack to get this out immediately and skip throttles.
+            OutPacket(teleport, ThrottleOutPacketType.Unknown);
+        }
+
+        /// <summary>
+        /// Inform the client that a teleport attempt has failed
+        /// </summary>
+        public void SendTeleportFailed(string reason)
+        {
+            TeleportFailedPacket tpFailed = (TeleportFailedPacket)PacketPool.Instance.GetPacket(PacketType.TeleportFailed);
+            tpFailed.Info.AgentID = AgentId;
+            tpFailed.Info.Reason = Util.StringToBytes256(reason);
+            tpFailed.AlertInfo = new TeleportFailedPacket.AlertInfoBlock[0];
+
+            // Hack to get this out immediately and skip throttles
+            OutPacket(tpFailed, ThrottleOutPacketType.Unknown);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public void SendTeleportStart(uint flags)
+        {
+            TeleportStartPacket tpStart = (TeleportStartPacket)PacketPool.Instance.GetPacket(PacketType.TeleportStart);
+            //TeleportStartPacket tpStart = new TeleportStartPacket();
+            tpStart.Info.TeleportFlags = flags; //16; // Teleport via location
+
+            // Hack to get this out immediately and skip throttles
+            OutPacket(tpStart, ThrottleOutPacketType.Unknown);
+        }
+
+        public void SendTeleportProgress(uint flags, string message)
+        {
+            TeleportProgressPacket tpProgress = (TeleportProgressPacket)PacketPool.Instance.GetPacket(PacketType.TeleportProgress);
+            tpProgress.AgentData.AgentID = this.AgentId;
+            tpProgress.Info.TeleportFlags = flags;
+            tpProgress.Info.Message = Util.StringToBytes256(message);
+
+            // Hack to get this out immediately and skip throttles
+            OutPacket(tpProgress, ThrottleOutPacketType.Unknown);
+        }
+
+        public void SendMoneyBalance(UUID transaction, bool success, byte[] description, int balance, int transactionType, UUID sourceID, bool sourceIsGroup, UUID destID, bool destIsGroup, int amount, string item)
+        {
+            MoneyBalanceReplyPacket money = (MoneyBalanceReplyPacket)PacketPool.Instance.GetPacket(PacketType.MoneyBalanceReply);
+            money.MoneyData.AgentID = AgentId;
+            money.MoneyData.TransactionID = transaction;
+            money.MoneyData.TransactionSuccess = success;
+            money.MoneyData.Description = description;
+            money.MoneyData.MoneyBalance = balance;
+            money.TransactionInfo.TransactionType = transactionType;
+            money.TransactionInfo.SourceID = sourceID;
+            money.TransactionInfo.IsSourceGroup = sourceIsGroup;
+            money.TransactionInfo.DestID = destID;
+            money.TransactionInfo.IsDestGroup = destIsGroup;
+            money.TransactionInfo.Amount = amount;
+            money.TransactionInfo.ItemDescription = Util.StringToBytes256(item);
+
+            OutPacket(money, ThrottleOutPacketType.Task);
+        }
+
+        public void SendPayPrice(UUID objectID, int[] payPrice)
+        {
+            if (payPrice[0] == 0 &&
+                payPrice[1] == 0 &&
+                payPrice[2] == 0 &&
+                payPrice[3] == 0 &&
+                payPrice[4] == 0)
+                return;
+
+            PayPriceReplyPacket payPriceReply = (PayPriceReplyPacket)PacketPool.Instance.GetPacket(PacketType.PayPriceReply);
+            payPriceReply.ObjectData.ObjectID = objectID;
+            payPriceReply.ObjectData.DefaultPayPrice = payPrice[0];
+
+            payPriceReply.ButtonData = new PayPriceReplyPacket.ButtonDataBlock[4];
+            payPriceReply.ButtonData[0] = new PayPriceReplyPacket.ButtonDataBlock();
+            payPriceReply.ButtonData[0].PayButton = payPrice[1];
+            payPriceReply.ButtonData[1] = new PayPriceReplyPacket.ButtonDataBlock();
+            payPriceReply.ButtonData[1].PayButton = payPrice[2];
+            payPriceReply.ButtonData[2] = new PayPriceReplyPacket.ButtonDataBlock();
+            payPriceReply.ButtonData[2].PayButton = payPrice[3];
+            payPriceReply.ButtonData[3] = new PayPriceReplyPacket.ButtonDataBlock();
+            payPriceReply.ButtonData[3].PayButton = payPrice[4];
+
+            OutPacket(payPriceReply, ThrottleOutPacketType.Task);
+        }
+
+        public void SendStartPingCheck(byte seq)
+        {
+            StartPingCheckPacket pc = (StartPingCheckPacket)PacketPool.Instance.GetPacket(PacketType.StartPingCheck);
+            pc.Header.Reliable = false;
+
+            pc.PingID.PingID = seq;
+            // We *could* get OldestUnacked, but it would hurt performance and not provide any benefit
+            pc.PingID.OldestUnacked = 0;
+
+            OutPacket(pc, ThrottleOutPacketType.Unknown);
+            UDPClient.m_lastStartpingTimeMS = Util.EnvironmentTickCount();
+        }
+
+        public void SendKillObject(List<uint> localIDs)
+        {
+            //            foreach (uint id in localIDs)
+            //                m_log.DebugFormat("[CLIENT]: Sending KillObjectPacket to {0} for {1} in {2}", Name, id, regionHandle);
+
+            // remove pending entities to reduce looping chances.
+            lock (m_entityProps.SyncRoot)
+                m_entityProps.Remove(localIDs);
+            lock (m_entityUpdates.SyncRoot)
+                m_entityUpdates.Remove(localIDs);
+
+            KillObjectPacket kill = (KillObjectPacket)PacketPool.Instance.GetPacket(PacketType.KillObject);
+
+            int perpacket = localIDs.Count;
+            if(perpacket > 200)
+                perpacket = 200;
+
+            int nsent = 0;
+
+            kill.ObjectData = new KillObjectPacket.ObjectDataBlock[perpacket];
+            for (int i = 0 ; i < localIDs.Count ; i++ )
+            {
+                kill.ObjectData[nsent] = new KillObjectPacket.ObjectDataBlock();
+                kill.ObjectData[nsent].ID = localIDs[i];
+
+                if(++nsent >= 200)
+                {
+                    kill.Header.Reliable = true;
+                    kill.Header.Zerocoded = true;
+                    OutPacket(kill, ThrottleOutPacketType.Task);
+
+                    perpacket = localIDs.Count - i - 1;
+                    if(perpacket == 0)
+                        break;
+                    if(perpacket > 200)
+                        perpacket = 200;
+
+                    kill = (KillObjectPacket)PacketPool.Instance.GetPacket(PacketType.KillObject);
+                    kill.ObjectData = new KillObjectPacket.ObjectDataBlock[perpacket];
+                    nsent = 0;
+                }
+            }
+
+            if(nsent != 0)
+            {
+                kill.Header.Reliable = true;
+                kill.Header.Zerocoded = true;
+                OutPacket(kill, ThrottleOutPacketType.Task);
+            }
+         }
+
+        /// <summary>
+        /// Send information about the items contained in a folder to the client.
+        /// </summary>
+        /// <remarks>
+        /// XXX This method needs some refactoring loving
+        /// </remarks>
+        /// <param name="ownerID">The owner of the folder</param>
+        /// <param name="folderID">The id of the folder</param>
+        /// <param name="items">The items contained in the folder identified by folderID</param>
+        /// <param name="folders"></param>
+        /// <param name="fetchFolders">Do we need to send folder information?</param>
+        /// <param name="fetchItems">Do we need to send item information?</param>
+        public void SendInventoryFolderDetails(UUID ownerID, UUID folderID, List<InventoryItemBase> items,
+                                               List<InventoryFolderBase> folders, int version,
+                                               bool fetchFolders, bool fetchItems)
+        {
+            // An inventory descendents packet consists of a single agent section and an inventory details
+            // section for each inventory item.  The size of each inventory item is approximately 550 bytes.
+            // In theory, UDP has a maximum packet size of 64k, so it should be possible to send descendent
+            // packets containing metadata for in excess of 100 items.  But in practice, there may be other
+            // factors (e.g. firewalls) restraining the maximum UDP packet size.  See,
+            //
+            // http://opensimulator.org/mantis/view.php?id=226
+            //
+            // for one example of this kind of thing.  In fact, the Linden servers appear to only send about
+            // 6 to 7 items at a time, so let's stick with 6
+            int MAX_ITEMS_PER_PACKET = 5;
+            int MAX_FOLDERS_PER_PACKET = 6;
+
+            int totalItems = fetchItems ? items.Count : 0;
+            int totalFolders = fetchFolders ? folders.Count : 0;
+            int itemsSent = 0;
+            int foldersSent = 0;
+            int foldersToSend = 0;
+            int itemsToSend = 0;
+
+            InventoryDescendentsPacket currentPacket = null;
+
+            // Handle empty folders
+            //
+            if (totalItems == 0 && totalFolders == 0)
+                currentPacket = CreateInventoryDescendentsPacket(ownerID, folderID, version, items.Count + folders.Count, 0, 0);
+
+            // To preserve SL compatibility, we will NOT combine folders and items in one packet
+            //
+            while (itemsSent < totalItems || foldersSent < totalFolders)
+            {
+                if (currentPacket == null) // Start a new packet
+                {
+                    foldersToSend = totalFolders - foldersSent;
+                    if (foldersToSend > MAX_FOLDERS_PER_PACKET)
+                        foldersToSend = MAX_FOLDERS_PER_PACKET;
+
+                    if (foldersToSend == 0)
+                    {
+                        itemsToSend = totalItems - itemsSent;
+                        if (itemsToSend > MAX_ITEMS_PER_PACKET)
+                            itemsToSend = MAX_ITEMS_PER_PACKET;
+                    }
+
+                    currentPacket = CreateInventoryDescendentsPacket(ownerID, folderID, version, items.Count + folders.Count, foldersToSend, itemsToSend);
+                }
+
+                if (foldersToSend-- > 0)
+                    currentPacket.FolderData[foldersSent % MAX_FOLDERS_PER_PACKET] = CreateFolderDataBlock(folders[foldersSent++]);
+                else if (itemsToSend-- > 0)
+                    currentPacket.ItemData[itemsSent % MAX_ITEMS_PER_PACKET] = CreateItemDataBlock(items[itemsSent++]);
+                else
+                {
+//                    m_log.DebugFormat(
+//                        "[LLCLIENTVIEW]: Sending inventory folder details packet to {0} for folder {1}", Name, folderID);
+                    OutPacket(currentPacket, ThrottleOutPacketType.Asset, false);
+                    currentPacket = null;
+                }
+            }
+
+            if (currentPacket != null)
+            {
+//                m_log.DebugFormat(
+//                    "[LLCLIENTVIEW]: Sending inventory folder details packet to {0} for folder {1}", Name, folderID);
+                OutPacket(currentPacket, ThrottleOutPacketType.Asset, false);
+            }
+        }
+
+        private InventoryDescendentsPacket.FolderDataBlock CreateFolderDataBlock(InventoryFolderBase folder)
+        {
+            InventoryDescendentsPacket.FolderDataBlock newBlock = new InventoryDescendentsPacket.FolderDataBlock();
+            newBlock.FolderID = folder.ID;
+            newBlock.Name = Util.StringToBytes256(folder.Name);
+            newBlock.ParentID = folder.ParentID;
+            newBlock.Type = (sbyte)folder.Type;
+            //if (newBlock.Type == InventoryItemBase.SUITCASE_FOLDER_TYPE)
+            //    newBlock.Type = InventoryItemBase.SUITCASE_FOLDER_FAKE_TYPE;
+
+            return newBlock;
+        }
+
+        private InventoryDescendentsPacket.ItemDataBlock CreateItemDataBlock(InventoryItemBase item)
+        {
+            InventoryDescendentsPacket.ItemDataBlock newBlock = new InventoryDescendentsPacket.ItemDataBlock();
+            newBlock.ItemID = item.ID;
+            newBlock.AssetID = item.AssetID;
+            newBlock.CreatorID = item.CreatorIdAsUuid;
+            newBlock.BaseMask = item.BasePermissions;
+            newBlock.Description = Util.StringToBytes256(item.Description);
+            newBlock.EveryoneMask = item.EveryOnePermissions;
+            newBlock.OwnerMask = item.CurrentPermissions;
+            newBlock.FolderID = item.Folder;
+            newBlock.InvType = (sbyte)item.InvType;
+            newBlock.Name = Util.StringToBytes256(item.Name);
+            newBlock.NextOwnerMask = item.NextPermissions;
+            newBlock.OwnerID = item.Owner;
+            newBlock.Type = (sbyte)item.AssetType;
+
+            newBlock.GroupID = item.GroupID;
+            newBlock.GroupOwned = item.GroupOwned;
+            newBlock.GroupMask = item.GroupPermissions;
+            newBlock.CreationDate = item.CreationDate;
+            newBlock.SalePrice = item.SalePrice;
+            newBlock.SaleType = item.SaleType;
+            newBlock.Flags = item.Flags & 0x2000ff;
+
+            newBlock.CRC =
+                Helpers.InventoryCRC(newBlock.CreationDate, newBlock.SaleType,
+                                     newBlock.InvType, newBlock.Type,
+                                     newBlock.AssetID, newBlock.GroupID,
+                                     newBlock.SalePrice,
+                                     newBlock.OwnerID, newBlock.CreatorID,
+                                     newBlock.ItemID, newBlock.FolderID,
+                                     newBlock.EveryoneMask,
+                                     newBlock.Flags, newBlock.OwnerMask,
+                                     newBlock.GroupMask, newBlock.NextOwnerMask);
+
+            return newBlock;
+        }
+
+        private void AddNullFolderBlockToDecendentsPacket(ref InventoryDescendentsPacket packet)
+        {
+            packet.FolderData = new InventoryDescendentsPacket.FolderDataBlock[1];
+            packet.FolderData[0] = new InventoryDescendentsPacket.FolderDataBlock();
+            packet.FolderData[0].FolderID = UUID.Zero;
+            packet.FolderData[0].ParentID = UUID.Zero;
+            packet.FolderData[0].Type = -1;
+            packet.FolderData[0].Name = new byte[0];
+        }
+
+        private void AddNullItemBlockToDescendentsPacket(ref InventoryDescendentsPacket packet)
+        {
+            packet.ItemData = new InventoryDescendentsPacket.ItemDataBlock[1];
+            packet.ItemData[0] = new InventoryDescendentsPacket.ItemDataBlock();
+            packet.ItemData[0].ItemID = UUID.Zero;
+            packet.ItemData[0].AssetID = UUID.Zero;
+            packet.ItemData[0].CreatorID = UUID.Zero;
+            packet.ItemData[0].BaseMask = 0;
+            packet.ItemData[0].Description = new byte[0];
+            packet.ItemData[0].EveryoneMask = 0;
+            packet.ItemData[0].OwnerMask = 0;
+            packet.ItemData[0].FolderID = UUID.Zero;
+            packet.ItemData[0].InvType = (sbyte)0;
+            packet.ItemData[0].Name = new byte[0];
+            packet.ItemData[0].NextOwnerMask = 0;
+            packet.ItemData[0].OwnerID = UUID.Zero;
+            packet.ItemData[0].Type = -1;
+
+            packet.ItemData[0].GroupID = UUID.Zero;
+            packet.ItemData[0].GroupOwned = false;
+            packet.ItemData[0].GroupMask = 0;
+            packet.ItemData[0].CreationDate = 0;
+            packet.ItemData[0].SalePrice = 0;
+            packet.ItemData[0].SaleType = 0;
+            packet.ItemData[0].Flags = 0;
+
+            // No need to add CRC
+        }
+
+        private InventoryDescendentsPacket CreateInventoryDescendentsPacket(UUID ownerID, UUID folderID, int version, int descendents, int folders, int items)
+        {
+            InventoryDescendentsPacket descend = (InventoryDescendentsPacket)PacketPool.Instance.GetPacket(PacketType.InventoryDescendents);
+            descend.Header.Zerocoded = true;
+            descend.AgentData.AgentID = AgentId;
+            descend.AgentData.OwnerID = ownerID;
+            descend.AgentData.FolderID = folderID;
+            descend.AgentData.Version = version;
+            descend.AgentData.Descendents = descendents;
+
+            if (folders > 0)
+                descend.FolderData = new InventoryDescendentsPacket.FolderDataBlock[folders];
+            else
+                AddNullFolderBlockToDecendentsPacket(ref descend);
+
+            if (items > 0)
+                descend.ItemData = new InventoryDescendentsPacket.ItemDataBlock[items];
+            else
+                AddNullItemBlockToDescendentsPacket(ref descend);
+
+            return descend;
+        }
+
+        public void SendInventoryItemDetails(UUID ownerID, InventoryItemBase item)
+        {
+            // Fudge this value. It's only needed to make the CRC anyway
+            const uint FULL_MASK_PERMISSIONS = (uint)0x7fffffff;
+
+            FetchInventoryReplyPacket inventoryReply = (FetchInventoryReplyPacket)PacketPool.Instance.GetPacket(PacketType.FetchInventoryReply);
+            // TODO: don't create new blocks if recycling an old packet
+            inventoryReply.AgentData.AgentID = AgentId;
+            inventoryReply.InventoryData = new FetchInventoryReplyPacket.InventoryDataBlock[1];
+            inventoryReply.InventoryData[0] = new FetchInventoryReplyPacket.InventoryDataBlock();
+            inventoryReply.InventoryData[0].ItemID = item.ID;
+            inventoryReply.InventoryData[0].AssetID = item.AssetID;
+            inventoryReply.InventoryData[0].CreatorID = item.CreatorIdAsUuid;
+            inventoryReply.InventoryData[0].BaseMask = item.BasePermissions;
+            inventoryReply.InventoryData[0].CreationDate = item.CreationDate;
+
+            inventoryReply.InventoryData[0].Description = Util.StringToBytes256(item.Description);
+            inventoryReply.InventoryData[0].EveryoneMask = item.EveryOnePermissions;
+            inventoryReply.InventoryData[0].FolderID = item.Folder;
+            inventoryReply.InventoryData[0].InvType = (sbyte)item.InvType;
+            inventoryReply.InventoryData[0].Name = Util.StringToBytes256(item.Name);
+            inventoryReply.InventoryData[0].NextOwnerMask = item.NextPermissions;
+            inventoryReply.InventoryData[0].OwnerID = item.Owner;
+            inventoryReply.InventoryData[0].OwnerMask = item.CurrentPermissions;
+            inventoryReply.InventoryData[0].Type = (sbyte)item.AssetType;
+
+            inventoryReply.InventoryData[0].GroupID = item.GroupID;
+            inventoryReply.InventoryData[0].GroupOwned = item.GroupOwned;
+            inventoryReply.InventoryData[0].GroupMask = item.GroupPermissions;
+            inventoryReply.InventoryData[0].Flags = item.Flags;
+            inventoryReply.InventoryData[0].SalePrice = item.SalePrice;
+            inventoryReply.InventoryData[0].SaleType = item.SaleType;
+
+            inventoryReply.InventoryData[0].CRC =
+                Helpers.InventoryCRC(
+                    1000, 0, inventoryReply.InventoryData[0].InvType,
+                    inventoryReply.InventoryData[0].Type, inventoryReply.InventoryData[0].AssetID,
+                    inventoryReply.InventoryData[0].GroupID, 100,
+                    inventoryReply.InventoryData[0].OwnerID, inventoryReply.InventoryData[0].CreatorID,
+                    inventoryReply.InventoryData[0].ItemID, inventoryReply.InventoryData[0].FolderID,
+                    FULL_MASK_PERMISSIONS, 1, FULL_MASK_PERMISSIONS, FULL_MASK_PERMISSIONS,
+                    FULL_MASK_PERMISSIONS);
+            inventoryReply.Header.Zerocoded = true;
+            OutPacket(inventoryReply, ThrottleOutPacketType.Asset);
+        }
+
+        protected void SendBulkUpdateInventoryFolder(InventoryFolderBase folderBase)
+        {
+            // We will use the same transaction id for all the separate packets to be sent out in this update.
+            UUID transactionId = UUID.Random();
+
+            List<BulkUpdateInventoryPacket.FolderDataBlock> folderDataBlocks
+                = new List<BulkUpdateInventoryPacket.FolderDataBlock>();
+
+            SendBulkUpdateInventoryFolderRecursive(folderBase, ref folderDataBlocks, transactionId);
+
+            if (folderDataBlocks.Count > 0)
+            {
+                // We'll end up with some unsent folder blocks if there were some empty folders at the end of the list
+                // Send these now
+                BulkUpdateInventoryPacket bulkUpdate
+                    = (BulkUpdateInventoryPacket)PacketPool.Instance.GetPacket(PacketType.BulkUpdateInventory);
+                bulkUpdate.Header.Zerocoded = true;
+
+                bulkUpdate.AgentData.AgentID = AgentId;
+                bulkUpdate.AgentData.TransactionID = transactionId;
+                bulkUpdate.FolderData = folderDataBlocks.ToArray();
+                List<BulkUpdateInventoryPacket.ItemDataBlock> foo = new List<BulkUpdateInventoryPacket.ItemDataBlock>();
+                bulkUpdate.ItemData = foo.ToArray();
+
+                //m_log.Debug("SendBulkUpdateInventory :" + bulkUpdate);
+                OutPacket(bulkUpdate, ThrottleOutPacketType.Asset);
+            }
+        }
+
+        /// <summary>
+        /// Recursively construct bulk update packets to send folders and items
+        /// </summary>
+        /// <param name="folder"></param>
+        /// <param name="folderDataBlocks"></param>
+        /// <param name="transactionId"></param>
+        private void SendBulkUpdateInventoryFolderRecursive(
+            InventoryFolderBase folder, ref List<BulkUpdateInventoryPacket.FolderDataBlock> folderDataBlocks,
+            UUID transactionId)
+        {
+            folderDataBlocks.Add(GenerateBulkUpdateFolderDataBlock(folder));
+
+            const int MAX_ITEMS_PER_PACKET = 5;
+
+            IInventoryService invService = m_scene.RequestModuleInterface<IInventoryService>();
+            // If there are any items then we have to start sending them off in this packet - the next folder will have
+            // to be in its own bulk update packet.  Also, we can only fit 5 items in a packet (at least this was the limit
+            // being used on the Linden grid at 20081203).
+            InventoryCollection contents = invService.GetFolderContent(AgentId, folder.ID); // folder.RequestListOfItems();
+            List<InventoryItemBase> items = contents.Items;
+            while (items.Count > 0)
+            {
+                BulkUpdateInventoryPacket bulkUpdate
+                    = (BulkUpdateInventoryPacket)PacketPool.Instance.GetPacket(PacketType.BulkUpdateInventory);
+                bulkUpdate.Header.Zerocoded = true;
+
+                bulkUpdate.AgentData.AgentID = AgentId;
+                bulkUpdate.AgentData.TransactionID = transactionId;
+                bulkUpdate.FolderData = folderDataBlocks.ToArray();
+
+                int itemsToSend = (items.Count > MAX_ITEMS_PER_PACKET ? MAX_ITEMS_PER_PACKET : items.Count);
+                bulkUpdate.ItemData = new BulkUpdateInventoryPacket.ItemDataBlock[itemsToSend];
+
+                for (int i = 0; i < itemsToSend; i++)
+                {
+                    // Remove from the end of the list so that we don't incur a performance penalty
+                    bulkUpdate.ItemData[i] = GenerateBulkUpdateItemDataBlock(items[items.Count - 1]);
+                    items.RemoveAt(items.Count - 1);
+                }
+
+                //m_log.Debug("SendBulkUpdateInventoryRecursive :" + bulkUpdate);
+                OutPacket(bulkUpdate, ThrottleOutPacketType.Asset);
+
+                folderDataBlocks = new List<BulkUpdateInventoryPacket.FolderDataBlock>();
+
+                // If we're going to be sending another items packet then it needs to contain just the folder to which those
+                // items belong.
+                if (items.Count > 0)
+                    folderDataBlocks.Add(GenerateBulkUpdateFolderDataBlock(folder));
+            }
+
+            List<InventoryFolderBase> subFolders = contents.Folders;
+            foreach (InventoryFolderBase subFolder in subFolders)
+            {
+                SendBulkUpdateInventoryFolderRecursive(subFolder, ref folderDataBlocks, transactionId);
+            }
+        }
+
+        /// <summary>
+        /// Generate a bulk update inventory data block for the given folder
+        /// </summary>
+        /// <param name="folder"></param>
+        /// <returns></returns>
+        private BulkUpdateInventoryPacket.FolderDataBlock GenerateBulkUpdateFolderDataBlock(InventoryFolderBase folder)
+        {
+            BulkUpdateInventoryPacket.FolderDataBlock folderBlock = new BulkUpdateInventoryPacket.FolderDataBlock();
+
+            folderBlock.FolderID = folder.ID;
+            folderBlock.ParentID = folder.ParentID;
+            folderBlock.Type = (sbyte)folder.Type;
+            // Leaving this here for now, just in case we need to do this for a while
+            //if (folderBlock.Type == InventoryItemBase.SUITCASE_FOLDER_TYPE)
+            //    folderBlock.Type = InventoryItemBase.SUITCASE_FOLDER_FAKE_TYPE;
+            folderBlock.Name = Util.StringToBytes256(folder.Name);
+
+            return folderBlock;
+        }
+
+        /// <summary>
+        /// Generate a bulk update inventory data block for the given item
+        /// </summary>
+        /// <param name="item"></param>
+        /// <returns></returns>
+        private BulkUpdateInventoryPacket.ItemDataBlock GenerateBulkUpdateItemDataBlock(InventoryItemBase item)
+        {
+            BulkUpdateInventoryPacket.ItemDataBlock itemBlock = new BulkUpdateInventoryPacket.ItemDataBlock();
+
+            itemBlock.ItemID = item.ID;
+            itemBlock.AssetID = item.AssetID;
+            itemBlock.CreatorID = item.CreatorIdAsUuid;
+            itemBlock.BaseMask = item.BasePermissions;
+            itemBlock.Description = Util.StringToBytes256(item.Description);
+            itemBlock.EveryoneMask = item.EveryOnePermissions;
+            itemBlock.FolderID = item.Folder;
+            itemBlock.InvType = (sbyte)item.InvType;
+            itemBlock.Name = Util.StringToBytes256(item.Name);
+            itemBlock.NextOwnerMask = item.NextPermissions;
+            itemBlock.OwnerID = item.Owner;
+            itemBlock.OwnerMask = item.CurrentPermissions;
+            itemBlock.Type = (sbyte)item.AssetType;
+            itemBlock.GroupID = item.GroupID;
+            itemBlock.GroupOwned = item.GroupOwned;
+            itemBlock.GroupMask = item.GroupPermissions;
+            itemBlock.Flags = item.Flags & 0x2000ff;
+            itemBlock.SalePrice = item.SalePrice;
+            itemBlock.SaleType = item.SaleType;
+            itemBlock.CreationDate = item.CreationDate;
+
+            itemBlock.CRC =
+                Helpers.InventoryCRC(
+                    1000, 0, itemBlock.InvType,
+                    itemBlock.Type, itemBlock.AssetID,
+                    itemBlock.GroupID, 100,
+                    itemBlock.OwnerID, itemBlock.CreatorID,
+                    itemBlock.ItemID, itemBlock.FolderID,
+                    (uint)PermissionMask.All, 1, (uint)PermissionMask.All, (uint)PermissionMask.All,
+                    (uint)PermissionMask.All);
+
+            return itemBlock;
+        }
+
+        public void SendBulkUpdateInventory(InventoryNodeBase node)
+        {
+            if (node is InventoryItemBase)
+                SendBulkUpdateInventoryItem((InventoryItemBase)node);
+            else if (node is InventoryFolderBase)
+                SendBulkUpdateInventoryFolder((InventoryFolderBase)node);
+            else if (node != null)
+                m_log.ErrorFormat("[CLIENT]: {0} sent unknown inventory node named {1}", Name, node.Name);
+            else
+                m_log.ErrorFormat("[CLIENT]: {0} sent null inventory node", Name);
+        }
+
+        protected void SendBulkUpdateInventoryItem(InventoryItemBase item)
+        {
+            const uint FULL_MASK_PERMISSIONS = (uint)0x7ffffff;
+
+            BulkUpdateInventoryPacket bulkUpdate
+                = (BulkUpdateInventoryPacket)PacketPool.Instance.GetPacket(PacketType.BulkUpdateInventory);
+
+            bulkUpdate.AgentData.AgentID = AgentId;
+            bulkUpdate.AgentData.TransactionID = UUID.Random();
+
+            bulkUpdate.FolderData = new BulkUpdateInventoryPacket.FolderDataBlock[1];
+            bulkUpdate.FolderData[0] = new BulkUpdateInventoryPacket.FolderDataBlock();
+            bulkUpdate.FolderData[0].FolderID = UUID.Zero;
+            bulkUpdate.FolderData[0].ParentID = UUID.Zero;
+            bulkUpdate.FolderData[0].Type = -1;
+            bulkUpdate.FolderData[0].Name = new byte[0];
+
+            bulkUpdate.ItemData = new BulkUpdateInventoryPacket.ItemDataBlock[1];
+            bulkUpdate.ItemData[0] = new BulkUpdateInventoryPacket.ItemDataBlock();
+            bulkUpdate.ItemData[0].ItemID = item.ID;
+            bulkUpdate.ItemData[0].AssetID = item.AssetID;
+            bulkUpdate.ItemData[0].CreatorID = item.CreatorIdAsUuid;
+            bulkUpdate.ItemData[0].BaseMask = item.BasePermissions;
+            bulkUpdate.ItemData[0].CreationDate = item.CreationDate;
+            bulkUpdate.ItemData[0].Description = Util.StringToBytes256(item.Description);
+            bulkUpdate.ItemData[0].EveryoneMask = item.EveryOnePermissions;
+            bulkUpdate.ItemData[0].FolderID = item.Folder;
+            bulkUpdate.ItemData[0].InvType = (sbyte)item.InvType;
+            bulkUpdate.ItemData[0].Name = Util.StringToBytes256(item.Name);
+            bulkUpdate.ItemData[0].NextOwnerMask = item.NextPermissions;
+            bulkUpdate.ItemData[0].OwnerID = item.Owner;
+            bulkUpdate.ItemData[0].OwnerMask = item.CurrentPermissions;
+            bulkUpdate.ItemData[0].Type = (sbyte)item.AssetType;
+
+            bulkUpdate.ItemData[0].GroupID = item.GroupID;
+            bulkUpdate.ItemData[0].GroupOwned = item.GroupOwned;
+            bulkUpdate.ItemData[0].GroupMask = item.GroupPermissions;
+            bulkUpdate.ItemData[0].Flags = item.Flags & 0x2000ff;
+            bulkUpdate.ItemData[0].SalePrice = item.SalePrice;
+            bulkUpdate.ItemData[0].SaleType = item.SaleType;
+
+            bulkUpdate.ItemData[0].CRC =
+                Helpers.InventoryCRC(1000, 0, bulkUpdate.ItemData[0].InvType,
+                                     bulkUpdate.ItemData[0].Type, bulkUpdate.ItemData[0].AssetID,
+                                     bulkUpdate.ItemData[0].GroupID, 100,
+                                     bulkUpdate.ItemData[0].OwnerID, bulkUpdate.ItemData[0].CreatorID,
+                                     bulkUpdate.ItemData[0].ItemID, bulkUpdate.ItemData[0].FolderID,
+                                     FULL_MASK_PERMISSIONS, 1, FULL_MASK_PERMISSIONS, FULL_MASK_PERMISSIONS,
+                                     FULL_MASK_PERMISSIONS);
+            bulkUpdate.Header.Zerocoded = true;
+            OutPacket(bulkUpdate, ThrottleOutPacketType.Asset);
+        }
+
+        public void SendInventoryItemCreateUpdate(InventoryItemBase Item, uint callbackId)
+        {
+            SendInventoryItemCreateUpdate(Item, UUID.Zero, callbackId);
+        }
+
+        /// <see>IClientAPI.SendInventoryItemCreateUpdate(InventoryItemBase)</see>
+        public void SendInventoryItemCreateUpdate(InventoryItemBase Item, UUID transactionID, uint callbackId)
+        {
+            const uint FULL_MASK_PERMISSIONS = (uint)0x7fffffff;
+
+            UpdateCreateInventoryItemPacket InventoryReply
+                = (UpdateCreateInventoryItemPacket)PacketPool.Instance.GetPacket(
+                                                       PacketType.UpdateCreateInventoryItem);
+
+            // TODO: don't create new blocks if recycling an old packet
+            InventoryReply.AgentData.AgentID = AgentId;
+            InventoryReply.AgentData.SimApproved = true;
+            InventoryReply.AgentData.TransactionID = transactionID;
+            InventoryReply.InventoryData = new UpdateCreateInventoryItemPacket.InventoryDataBlock[1];
+            InventoryReply.InventoryData[0] = new UpdateCreateInventoryItemPacket.InventoryDataBlock();
+            InventoryReply.InventoryData[0].ItemID = Item.ID;
+            InventoryReply.InventoryData[0].AssetID = Item.AssetID;
+            InventoryReply.InventoryData[0].CreatorID = Item.CreatorIdAsUuid;
+            InventoryReply.InventoryData[0].BaseMask = Item.BasePermissions;
+            InventoryReply.InventoryData[0].Description = Util.StringToBytes256(Item.Description);
+            InventoryReply.InventoryData[0].EveryoneMask = Item.EveryOnePermissions;
+            InventoryReply.InventoryData[0].FolderID = Item.Folder;
+            InventoryReply.InventoryData[0].InvType = (sbyte)Item.InvType;
+            InventoryReply.InventoryData[0].Name = Util.StringToBytes256(Item.Name);
+            InventoryReply.InventoryData[0].NextOwnerMask = Item.NextPermissions;
+            InventoryReply.InventoryData[0].OwnerID = Item.Owner;
+            InventoryReply.InventoryData[0].OwnerMask = Item.CurrentPermissions;
+            InventoryReply.InventoryData[0].Type = (sbyte)Item.AssetType;
+            InventoryReply.InventoryData[0].CallbackID = callbackId;
+
+            InventoryReply.InventoryData[0].GroupID = Item.GroupID;
+            InventoryReply.InventoryData[0].GroupOwned = Item.GroupOwned;
+            InventoryReply.InventoryData[0].GroupMask = Item.GroupPermissions;
+            InventoryReply.InventoryData[0].Flags = Item.Flags & 0x2000ff;
+            InventoryReply.InventoryData[0].SalePrice = Item.SalePrice;
+            InventoryReply.InventoryData[0].SaleType = Item.SaleType;
+            InventoryReply.InventoryData[0].CreationDate = Item.CreationDate;
+
+            InventoryReply.InventoryData[0].CRC =
+                Helpers.InventoryCRC(1000, 0, InventoryReply.InventoryData[0].InvType,
+                                     InventoryReply.InventoryData[0].Type, InventoryReply.InventoryData[0].AssetID,
+                                     InventoryReply.InventoryData[0].GroupID, 100,
+                                     InventoryReply.InventoryData[0].OwnerID, InventoryReply.InventoryData[0].CreatorID,
+                                     InventoryReply.InventoryData[0].ItemID, InventoryReply.InventoryData[0].FolderID,
+                                     FULL_MASK_PERMISSIONS, 1, FULL_MASK_PERMISSIONS, FULL_MASK_PERMISSIONS,
+                                     FULL_MASK_PERMISSIONS);
+            InventoryReply.Header.Zerocoded = true;
+            OutPacket(InventoryReply, ThrottleOutPacketType.Asset);
+        }
+
+        public void SendRemoveInventoryItem(UUID itemID)
+        {
+            RemoveInventoryItemPacket remove = (RemoveInventoryItemPacket)PacketPool.Instance.GetPacket(PacketType.RemoveInventoryItem);
+            // TODO: don't create new blocks if recycling an old packet
+            remove.AgentData.AgentID = AgentId;
+            remove.AgentData.SessionID = m_sessionId;
+            remove.InventoryData = new RemoveInventoryItemPacket.InventoryDataBlock[1];
+            remove.InventoryData[0] = new RemoveInventoryItemPacket.InventoryDataBlock();
+            remove.InventoryData[0].ItemID = itemID;
+            remove.Header.Zerocoded = true;
+            OutPacket(remove, ThrottleOutPacketType.Asset);
+        }
+
+/*
+        private uint adjustControls(int input)
+        {
+            uint ret = (uint)input;
+            uint masked = ret & 0x0f;
+            masked <<= 19;
+            ret |= masked;
+            return ret;
+        }
+*/
+
+        public void SendTakeControls(int controls, bool passToAgent, bool TakeControls)
+        {
+            ScriptControlChangePacket scriptcontrol = (ScriptControlChangePacket)PacketPool.Instance.GetPacket(PacketType.ScriptControlChange);
+            ScriptControlChangePacket.DataBlock[] data = new ScriptControlChangePacket.DataBlock[1];
+            ScriptControlChangePacket.DataBlock ddata = new ScriptControlChangePacket.DataBlock();
+//            ddata.Controls = adjustControls(controls);
+            ddata.Controls = (uint)controls;
+            ddata.PassToAgent = passToAgent;
+            ddata.TakeControls = TakeControls;
+            data[0] = ddata;
+            scriptcontrol.Data = data;
+            OutPacket(scriptcontrol, ThrottleOutPacketType.Task);
+        }
+
+        public void SendTaskInventory(UUID taskID, short serial, byte[] fileName)
+        {
+            ReplyTaskInventoryPacket replytask = (ReplyTaskInventoryPacket)PacketPool.Instance.GetPacket(PacketType.ReplyTaskInventory);
+            replytask.InventoryData.TaskID = taskID;
+            replytask.InventoryData.Serial = serial;
+            replytask.InventoryData.Filename = fileName;
+//            OutPacket(replytask, ThrottleOutPacketType.Task);
+            OutPacket(replytask, ThrottleOutPacketType.Asset);
+        }
+
+        public void SendXferPacket(ulong xferID, uint packet, byte[] data, bool isTaskInventory)
+        {
+            ThrottleOutPacketType type = ThrottleOutPacketType.Asset;
+//            if (isTaskInventory)
+//                type = ThrottleOutPacketType.Task;
+
+            SendXferPacketPacket sendXfer = (SendXferPacketPacket)PacketPool.Instance.GetPacket(PacketType.SendXferPacket);
+            sendXfer.XferID.ID = xferID;
+            sendXfer.XferID.Packet = packet;
+            sendXfer.DataPacket.Data = data;
+            OutPacket(sendXfer, type);
+        }
+
+        public void SendAbortXferPacket(ulong xferID)
+        {
+            AbortXferPacket xferItem = (AbortXferPacket)PacketPool.Instance.GetPacket(PacketType.AbortXfer);
+            xferItem.XferID.ID = xferID;
+            OutPacket(xferItem, ThrottleOutPacketType.Asset);
+        }
+
+        public void SendEconomyData(float EnergyEfficiency, int ObjectCapacity, int ObjectCount, int PriceEnergyUnit,
+                                    int PriceGroupCreate, int PriceObjectClaim, float PriceObjectRent, float PriceObjectScaleFactor,
+                                    int PriceParcelClaim, float PriceParcelClaimFactor, int PriceParcelRent, int PricePublicObjectDecay,
+                                    int PricePublicObjectDelete, int PriceRentLight, int PriceUpload, int TeleportMinPrice, float TeleportPriceExponent)
+        {
+            EconomyDataPacket economyData = (EconomyDataPacket)PacketPool.Instance.GetPacket(PacketType.EconomyData);
+            economyData.Info.EnergyEfficiency = EnergyEfficiency;
+            economyData.Info.ObjectCapacity = ObjectCapacity;
+            economyData.Info.ObjectCount = ObjectCount;
+            economyData.Info.PriceEnergyUnit = PriceEnergyUnit;
+            economyData.Info.PriceGroupCreate = PriceGroupCreate;
+            economyData.Info.PriceObjectClaim = PriceObjectClaim;
+            economyData.Info.PriceObjectRent = PriceObjectRent;
+            economyData.Info.PriceObjectScaleFactor = PriceObjectScaleFactor;
+            economyData.Info.PriceParcelClaim = PriceParcelClaim;
+            economyData.Info.PriceParcelClaimFactor = PriceParcelClaimFactor;
+            economyData.Info.PriceParcelRent = PriceParcelRent;
+            economyData.Info.PricePublicObjectDecay = PricePublicObjectDecay;
+            economyData.Info.PricePublicObjectDelete = PricePublicObjectDelete;
+            economyData.Info.PriceRentLight = PriceRentLight;
+            economyData.Info.PriceUpload = PriceUpload;
+            economyData.Info.TeleportMinPrice = TeleportMinPrice;
+            economyData.Info.TeleportPriceExponent = TeleportPriceExponent;
+            economyData.Header.Reliable = true;
+            OutPacket(economyData, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAvatarPickerReply(AvatarPickerReplyAgentDataArgs AgentData, List<AvatarPickerReplyDataArgs> Data)
+        {
+            //construct the AvatarPickerReply packet.
+            AvatarPickerReplyPacket replyPacket = new AvatarPickerReplyPacket();
+            replyPacket.AgentData.AgentID = AgentData.AgentID;
+            replyPacket.AgentData.QueryID = AgentData.QueryID;
+            //int i = 0;
+            List<AvatarPickerReplyPacket.DataBlock> data_block = new List<AvatarPickerReplyPacket.DataBlock>();
+            foreach (AvatarPickerReplyDataArgs arg in Data)
+            {
+                AvatarPickerReplyPacket.DataBlock db = new AvatarPickerReplyPacket.DataBlock();
+                db.AvatarID = arg.AvatarID;
+                db.FirstName = arg.FirstName;
+                db.LastName = arg.LastName;
+                data_block.Add(db);
+            }
+            replyPacket.Data = data_block.ToArray();
+            OutPacket(replyPacket, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAgentDataUpdate(UUID agentid, UUID activegroupid, string firstname, string lastname, ulong grouppowers, string groupname, string grouptitle)
+        {
+            if (agentid == AgentId)
+            {
+                ActiveGroupId = activegroupid;
+                ActiveGroupName = groupname;
+                ActiveGroupPowers = grouppowers;
+            }
+
+            AgentDataUpdatePacket sendAgentDataUpdate = (AgentDataUpdatePacket)PacketPool.Instance.GetPacket(PacketType.AgentDataUpdate);
+            sendAgentDataUpdate.AgentData.ActiveGroupID = activegroupid;
+            sendAgentDataUpdate.AgentData.AgentID = agentid;
+            sendAgentDataUpdate.AgentData.FirstName = Util.StringToBytes256(firstname);
+            sendAgentDataUpdate.AgentData.GroupName = Util.StringToBytes256(groupname);
+            sendAgentDataUpdate.AgentData.GroupPowers = grouppowers;
+            sendAgentDataUpdate.AgentData.GroupTitle = Util.StringToBytes256(grouptitle);
+            sendAgentDataUpdate.AgentData.LastName = Util.StringToBytes256(lastname);
+            OutPacket(sendAgentDataUpdate, ThrottleOutPacketType.Task);
+        }
+
+        /// <summary>
+        /// Send an alert message to the client.  On the Linden client (tested 1.19.1.4), this pops up a brief duration
+        /// blue information box in the bottom right hand corner.
+        /// </summary>
+        /// <param name="message"></param>
+        public void SendAlertMessage(string message)
+        {
+            AlertMessagePacket alertPack = (AlertMessagePacket)PacketPool.Instance.GetPacket(PacketType.AlertMessage);
+            alertPack.AlertData = new AlertMessagePacket.AlertDataBlock();
+            alertPack.AlertData.Message = Util.StringToBytes256(message);
+            alertPack.AlertInfo = new AlertMessagePacket.AlertInfoBlock[0];
+            OutPacket(alertPack, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAlertMessage(string message, string info)
+        {
+            AlertMessagePacket alertPack = (AlertMessagePacket)PacketPool.Instance.GetPacket(PacketType.AlertMessage);
+            alertPack.AlertData = new AlertMessagePacket.AlertDataBlock();
+            alertPack.AlertData.Message = Util.StringToBytes256(message);
+            alertPack.AlertInfo = new AlertMessagePacket.AlertInfoBlock[1];
+            alertPack.AlertInfo[0] = new AlertMessagePacket.AlertInfoBlock();
+            alertPack.AlertInfo[0].Message = Util.StringToBytes256(info);
+            alertPack.AlertInfo[0].ExtraParams = new Byte[0];
+            OutPacket(alertPack, ThrottleOutPacketType.Task);
+        }
+
+        /// <summary>
+        /// Send an agent alert message to the client.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="modal">On the linden client, if this true then it displays a one button text box placed in the
+        /// middle of the window.  If false, the message is displayed in a brief duration blue information box (as for
+        /// the AlertMessage packet).</param>
+        public void SendAgentAlertMessage(string message, bool modal)
+        {
+            OutPacket(BuildAgentAlertPacket(message, modal), ThrottleOutPacketType.Task);
+        }
+
+        /// <summary>
+        /// Construct an agent alert packet
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="modal"></param>
+        /// <returns></returns>
+        public AgentAlertMessagePacket BuildAgentAlertPacket(string message, bool modal)
+        {
+            // Prepend a slash to make the message come up in the top right
+            // again.
+            // Allow special formats to be sent from aware modules.
+            if (!modal && !message.StartsWith("ALERT: ") && !message.StartsWith("NOTIFY: ") && message != "Home position set." && message != "You died and have been teleported to your home location")
+                message = "/" + message;
+            AgentAlertMessagePacket alertPack = (AgentAlertMessagePacket)PacketPool.Instance.GetPacket(PacketType.AgentAlertMessage);
+            alertPack.AgentData.AgentID = AgentId;
+            alertPack.AlertData.Message = Util.StringToBytes256(message);
+            alertPack.AlertData.Modal = modal;
+
+            return alertPack;
+        }
+
+        public void SendLoadURL(string objectname, UUID objectID, UUID ownerID, bool groupOwned, string message,
+                                string url)
+        {
+            LoadURLPacket loadURL = (LoadURLPacket)PacketPool.Instance.GetPacket(PacketType.LoadURL);
+            loadURL.Data.ObjectName = Util.StringToBytes256(objectname);
+            loadURL.Data.ObjectID = objectID;
+            loadURL.Data.OwnerID = ownerID;
+            loadURL.Data.OwnerIsGroup = groupOwned;
+            loadURL.Data.Message = Util.StringToBytes256(message);
+            loadURL.Data.URL = Util.StringToBytes256(url);
+            OutPacket(loadURL, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDialog(
+            string objectname, UUID objectID, UUID ownerID, string ownerFirstName, string ownerLastName, string msg,
+            UUID textureID, int ch, string[] buttonlabels)
+        {
+            ScriptDialogPacket dialog = (ScriptDialogPacket)PacketPool.Instance.GetPacket(PacketType.ScriptDialog);
+            dialog.Data.ObjectID = objectID;
+            dialog.Data.ObjectName = Util.StringToBytes256(objectname);
+            // this is the username of the *owner*
+            dialog.Data.FirstName = Util.StringToBytes256(ownerFirstName);
+            dialog.Data.LastName = Util.StringToBytes256(ownerLastName);
+            dialog.Data.Message = Util.StringToBytes(msg,512);
+            dialog.Data.ImageID = textureID;
+            dialog.Data.ChatChannel = ch;
+            ScriptDialogPacket.ButtonsBlock[] buttons = new ScriptDialogPacket.ButtonsBlock[buttonlabels.Length];
+            for (int i = 0; i < buttonlabels.Length; i++)
+            {
+                buttons[i] = new ScriptDialogPacket.ButtonsBlock();
+                buttons[i].ButtonLabel = Util.StringToBytes256(buttonlabels[i]);
+            }
+            dialog.Buttons = buttons;
+
+            dialog.OwnerData = new ScriptDialogPacket.OwnerDataBlock[1];
+            dialog.OwnerData[0] = new ScriptDialogPacket.OwnerDataBlock();
+            dialog.OwnerData[0].OwnerID = ownerID;
+
+            OutPacket(dialog, ThrottleOutPacketType.Task);
+        }
+
+        public void SendPreLoadSound(UUID objectID, UUID ownerID, UUID soundID)
+        {
+            PreloadSoundPacket preSound = (PreloadSoundPacket)PacketPool.Instance.GetPacket(PacketType.PreloadSound);
+            // TODO: don't create new blocks if recycling an old packet
+            preSound.DataBlock = new PreloadSoundPacket.DataBlockBlock[1];
+            preSound.DataBlock[0] = new PreloadSoundPacket.DataBlockBlock();
+            preSound.DataBlock[0].ObjectID = objectID;
+            preSound.DataBlock[0].OwnerID = ownerID;
+            preSound.DataBlock[0].SoundID = soundID;
+            preSound.Header.Zerocoded = true;
+            OutPacket(preSound, ThrottleOutPacketType.Task);
+        }
+
+        public void SendPlayAttachedSound(UUID soundID, UUID objectID, UUID ownerID, float gain, byte flags)
+        {
+            AttachedSoundPacket sound = (AttachedSoundPacket)PacketPool.Instance.GetPacket(PacketType.AttachedSound);
+            sound.DataBlock.SoundID = soundID;
+            sound.DataBlock.ObjectID = objectID;
+            sound.DataBlock.OwnerID = ownerID;
+            sound.DataBlock.Gain = gain;
+            sound.DataBlock.Flags = flags;
+
+            OutPacket(sound, ThrottleOutPacketType.Task);
+        }
+
+        public void SendTransferAbort(TransferRequestPacket transferRequest)
+        {
+            TransferAbortPacket abort = (TransferAbortPacket)PacketPool.Instance.GetPacket(PacketType.TransferAbort);
+            abort.TransferInfo.TransferID = transferRequest.TransferInfo.TransferID;
+            abort.TransferInfo.ChannelType = transferRequest.TransferInfo.ChannelType;
+            m_log.Debug("[Assets] Aborting transfer; asset request failed");
+            OutPacket(abort, ThrottleOutPacketType.Task);
+        }
+
+        public void SendTriggeredSound(UUID soundID, UUID ownerID, UUID objectID, UUID parentID, ulong handle, Vector3 position, float gain)
+        {
+            SoundTriggerPacket sound = (SoundTriggerPacket)PacketPool.Instance.GetPacket(PacketType.SoundTrigger);
+            sound.SoundData.SoundID = soundID;
+            sound.SoundData.OwnerID = ownerID;
+            sound.SoundData.ObjectID = objectID;
+            sound.SoundData.ParentID = parentID;
+            sound.SoundData.Handle = handle;
+            sound.SoundData.Position = position;
+            sound.SoundData.Gain = gain;
+
+            OutPacket(sound, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAttachedSoundGainChange(UUID objectID, float gain)
+        {
+            AttachedSoundGainChangePacket sound = (AttachedSoundGainChangePacket)PacketPool.Instance.GetPacket(PacketType.AttachedSoundGainChange);
+            sound.DataBlock.ObjectID = objectID;
+            sound.DataBlock.Gain = gain;
+
+            OutPacket(sound, ThrottleOutPacketType.Task);
+        }
+
+        public void SendSunPos(Vector3 Position, Vector3 Velocity, ulong CurrentTime, uint SecondsPerSunCycle, uint SecondsPerYear, float OrbitalPosition)
+        {
+            // Viewers based on the Linden viwer code, do wacky things for oribital positions from Midnight to Sunrise
+            // So adjust for that
+            // Contributed by: Godfrey
+
+            if (OrbitalPosition > m_sunPainDaHalfOrbitalCutoff) // things get weird from midnight to sunrise
+            {
+                OrbitalPosition = (OrbitalPosition - m_sunPainDaHalfOrbitalCutoff) * 0.6666666667f + m_sunPainDaHalfOrbitalCutoff;
+            }
+
+            SimulatorViewerTimeMessagePacket viewertime = (SimulatorViewerTimeMessagePacket)PacketPool.Instance.GetPacket(PacketType.SimulatorViewerTimeMessage);
+            viewertime.TimeInfo.SunDirection = Position;
+            viewertime.TimeInfo.SunAngVelocity = Velocity;
+
+            // Sun module used to add 6 hours to adjust for linden sun hour, adding here
+            // to prevent existing code from breaking if it assumed that 6 hours were included.
+            // 21600 == 6 hours * 60 minutes * 60 Seconds
+            viewertime.TimeInfo.UsecSinceStart = CurrentTime + 21600;
+
+            viewertime.TimeInfo.SecPerDay = SecondsPerSunCycle;
+            viewertime.TimeInfo.SecPerYear = SecondsPerYear;
+            viewertime.TimeInfo.SunPhase = OrbitalPosition;
+            viewertime.Header.Reliable = false;
+            viewertime.Header.Zerocoded = true;
+            OutPacket(viewertime, ThrottleOutPacketType.Task);
+        }
+
+        // Currently Deprecated
+        public void SendViewerTime(int phase)
+        {
+            /*
+            Console.WriteLine("SunPhase: {0}", phase);
+            SimulatorViewerTimeMessagePacket viewertime = (SimulatorViewerTimeMessagePacket)PacketPool.Instance.GetPacket(PacketType.SimulatorViewerTimeMessage);
+            //viewertime.TimeInfo.SecPerDay = 86400;
+            //viewertime.TimeInfo.SecPerYear = 31536000;
+            viewertime.TimeInfo.SecPerDay = 1000;
+            viewertime.TimeInfo.SecPerYear = 365000;
+            viewertime.TimeInfo.SunPhase = 1;
+            int sunPhase = (phase + 2) / 2;
+            if ((sunPhase < 6) || (sunPhase > 36))
+            {
+                viewertime.TimeInfo.SunDirection = new Vector3(0f, 0.8f, -0.8f);
+                Console.WriteLine("sending night");
+            }
+            else
+            {
+                if (sunPhase < 12)
+                {
+                    sunPhase = 12;
+                }
+                sunPhase = sunPhase - 12;
+
+                float yValue = 0.1f * (sunPhase);
+                Console.WriteLine("Computed SunPhase: {0}, yValue: {1}", sunPhase, yValue);
+                if (yValue > 1.2f)
+                {
+                    yValue = yValue - 1.2f;
+                }
+
+                yValue = Util.Clip(yValue, 0, 1);
+
+                if (sunPhase < 14)
+                {
+                    yValue = 1 - yValue;
+                }
+                if (sunPhase < 12)
+                {
+                    yValue *= -1;
+                }
+                viewertime.TimeInfo.SunDirection = new Vector3(0f, yValue, 0.3f);
+                Console.WriteLine("sending sun update " + yValue);
+            }
+            viewertime.TimeInfo.SunAngVelocity = new Vector3(0, 0.0f, 10.0f);
+            viewertime.TimeInfo.UsecSinceStart = (ulong)Util.UnixTimeSinceEpoch();
+            viewertime.Header.Reliable = false;
+            OutPacket(viewertime, ThrottleOutPacketType.Task);
+            */
+        }
+
+        public void SendViewerEffect(ViewerEffectPacket.EffectBlock[] effectBlocks)
+        {
+            ViewerEffectPacket packet = (ViewerEffectPacket)PacketPool.Instance.GetPacket(PacketType.ViewerEffect);
+            packet.Header.Reliable = false;
+            packet.Header.Zerocoded = true;
+
+            packet.AgentData.AgentID = AgentId;
+            packet.AgentData.SessionID = SessionId;
+
+            packet.Effect = effectBlocks;
+
+            // OutPacket(packet, ThrottleOutPacketType.State);
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAvatarProperties(UUID avatarID, string aboutText, string bornOn, Byte[] membershipType,
+                                         string flAbout, uint flags, UUID flImageID, UUID imageID, string profileURL,
+                                         UUID partnerID)
+        {
+            AvatarPropertiesReplyPacket avatarReply = (AvatarPropertiesReplyPacket)PacketPool.Instance.GetPacket(PacketType.AvatarPropertiesReply);
+            avatarReply.AgentData.AgentID = AgentId;
+            avatarReply.AgentData.AvatarID = avatarID;
+            if (aboutText != null)
+                avatarReply.PropertiesData.AboutText = Util.StringToBytes1024(aboutText);
+            else
+                avatarReply.PropertiesData.AboutText = Utils.EmptyBytes;
+            avatarReply.PropertiesData.BornOn = Util.StringToBytes256(bornOn);
+            avatarReply.PropertiesData.CharterMember = membershipType;
+            if (flAbout != null)
+                avatarReply.PropertiesData.FLAboutText = Util.StringToBytes256(flAbout);
+            else
+                avatarReply.PropertiesData.FLAboutText = Utils.EmptyBytes;
+            avatarReply.PropertiesData.Flags = flags;
+            avatarReply.PropertiesData.FLImageID = flImageID;
+            avatarReply.PropertiesData.ImageID = imageID;
+            avatarReply.PropertiesData.ProfileURL = Util.StringToBytes256(profileURL);
+            avatarReply.PropertiesData.PartnerID = partnerID;
+            OutPacket(avatarReply, ThrottleOutPacketType.Task);
+        }
+
+        /// <summary>
+        /// Send the client an Estate message blue box pop-down with a single OK button
+        /// </summary>
+        /// <param name="FromAvatarID"></param>
+        /// <param name="fromSessionID"></param>
+        /// <param name="FromAvatarName"></param>
+        /// <param name="Message"></param>
+        public void SendBlueBoxMessage(UUID FromAvatarID, String FromAvatarName, String Message)
+        {
+            if (!SceneAgent.IsChildAgent)
+                SendInstantMessage(new GridInstantMessage(null, FromAvatarID, FromAvatarName, AgentId, 1, Message, false, new Vector3()));
+
+            //SendInstantMessage(FromAvatarID, fromSessionID, Message, AgentId, SessionId, FromAvatarName, (byte)21,(uint) Util.UnixTimeSinceEpoch());
+        }
+
+        public void SendLogoutPacket()
+        {
+            // I know this is a bit of a hack, however there are times when you don't
+            // want to send this, but still need to do the rest of the shutdown process
+            // this method gets called from the packet server..   which makes it practically
+            // impossible to do any other way.
+
+            if (m_SendLogoutPacketWhenClosing)
+            {
+                LogoutReplyPacket logReply = (LogoutReplyPacket)PacketPool.Instance.GetPacket(PacketType.LogoutReply);
+                // TODO: don't create new blocks if recycling an old packet
+                logReply.AgentData.AgentID = AgentId;
+                logReply.AgentData.SessionID = SessionId;
+                logReply.InventoryData = new LogoutReplyPacket.InventoryDataBlock[1];
+                logReply.InventoryData[0] = new LogoutReplyPacket.InventoryDataBlock();
+                logReply.InventoryData[0].ItemID = UUID.Zero;
+
+                OutPacket(logReply, ThrottleOutPacketType.Task);
+            }
+        }
+
+        public void SendHealth(float health)
+        {
+            HealthMessagePacket healthpacket = (HealthMessagePacket)PacketPool.Instance.GetPacket(PacketType.HealthMessage);
+            healthpacket.HealthData.Health = health;
+            OutPacket(healthpacket, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAgentOnline(UUID[] agentIDs)
+        {
+            OnlineNotificationPacket onp = new OnlineNotificationPacket();
+            OnlineNotificationPacket.AgentBlockBlock[] onpb = new OnlineNotificationPacket.AgentBlockBlock[agentIDs.Length];
+            for (int i = 0; i < agentIDs.Length; i++)
+            {
+                OnlineNotificationPacket.AgentBlockBlock onpbl = new OnlineNotificationPacket.AgentBlockBlock();
+                onpbl.AgentID = agentIDs[i];
+                onpb[i] = onpbl;
+            }
+            onp.AgentBlock = onpb;
+            onp.Header.Reliable = true;
+            OutPacket(onp, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAgentOffline(UUID[] agentIDs)
+        {
+            OfflineNotificationPacket offp = new OfflineNotificationPacket();
+            OfflineNotificationPacket.AgentBlockBlock[] offpb = new OfflineNotificationPacket.AgentBlockBlock[agentIDs.Length];
+            for (int i = 0; i < agentIDs.Length; i++)
+            {
+                OfflineNotificationPacket.AgentBlockBlock onpbl = new OfflineNotificationPacket.AgentBlockBlock();
+                onpbl.AgentID = agentIDs[i];
+                offpb[i] = onpbl;
+            }
+            offp.AgentBlock = offpb;
+            offp.Header.Reliable = true;
+            OutPacket(offp, ThrottleOutPacketType.Task);
+        }
+
+        public void SendFindAgent(UUID HunterID, UUID PreyID, double GlobalX, double GlobalY)
+        {
+            FindAgentPacket fap = new FindAgentPacket();
+            fap.AgentBlock.Hunter = HunterID;
+            fap.AgentBlock.Prey = PreyID;
+            fap.AgentBlock.SpaceIP = 0;
+
+            fap.LocationBlock = new FindAgentPacket.LocationBlockBlock[1];
+            fap.LocationBlock[0] = new FindAgentPacket.LocationBlockBlock();
+            fap.LocationBlock[0].GlobalX = GlobalX;
+            fap.LocationBlock[0].GlobalY = GlobalY;
+
+            OutPacket(fap, ThrottleOutPacketType.Task);
+         }
+
+        public void SendSitResponse(UUID TargetID, Vector3 OffsetPos,
+                Quaternion SitOrientation, bool autopilot,
+                Vector3 CameraAtOffset, Vector3 CameraEyeOffset, bool ForceMouseLook)
+        {
+            AvatarSitResponsePacket avatarSitResponse = new AvatarSitResponsePacket();
+            avatarSitResponse.SitObject.ID = TargetID;
+            avatarSitResponse.SitTransform.CameraAtOffset = CameraAtOffset;
+            avatarSitResponse.SitTransform.CameraEyeOffset = CameraEyeOffset;
+            avatarSitResponse.SitTransform.ForceMouselook = ForceMouseLook;
+            avatarSitResponse.SitTransform.AutoPilot = autopilot;
+            avatarSitResponse.SitTransform.SitPosition = OffsetPos;
+            avatarSitResponse.SitTransform.SitRotation = SitOrientation;
+
+            OutPacket(avatarSitResponse, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAdminResponse(UUID Token, uint AdminLevel)
+        {
+            GrantGodlikePowersPacket respondPacket = new GrantGodlikePowersPacket();
+            GrantGodlikePowersPacket.GrantDataBlock gdb = new GrantGodlikePowersPacket.GrantDataBlock();
+            GrantGodlikePowersPacket.AgentDataBlock adb = new GrantGodlikePowersPacket.AgentDataBlock();
+
+            adb.AgentID = AgentId;
+            adb.SessionID = SessionId; // More security
+            gdb.GodLevel = (byte)AdminLevel;
+            gdb.Token = Token;
+            //respondPacket.AgentData = (GrantGodlikePowersPacket.AgentDataBlock)ablock;
+            respondPacket.GrantData = gdb;
+            respondPacket.AgentData = adb;
+            OutPacket(respondPacket, ThrottleOutPacketType.Task);
+        }
+
+        public void SendGroupMembership(GroupMembershipData[] GroupMembership)
+        {
+
+            UpdateGroupMembership(GroupMembership);
+            SendAgentGroupDataUpdate(AgentId,GroupMembership);
+        }
+
+        public void SendSelectedPartsProprieties(List<ISceneEntity> parts)
+        {
+/* not in use
+            // udp part
+            ObjectPropertiesPacket packet =
+                (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
+            ObjectPropertiesPacket.ObjectDataBlock[] ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[parts.Count];
+
+            int i = 0;
+            foreach(SceneObjectPart sop in parts)
+                ObjectData[i++] = CreateObjectPropertiesBlock(sop);
+
+            packet.ObjectData = ObjectData;
+            packet.Header.Zerocoded = true;
+            // udp send splits this mega packets correctly
+            // mb later will avoid that to reduce gc stress
+            OutPacket(packet, ThrottleOutPacketType.Task, true);
+
+            // caps physics part
+            IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
+            if(eq == null)
+                return;
+
+            OSDArray array = new OSDArray();
+            foreach(SceneObjectPart sop in parts)
+            {
+                OSDMap physinfo = new OSDMap(6);
+                physinfo["LocalID"] = sop.LocalId;
+                physinfo["Density"] = sop.Density;
+                physinfo["Friction"] = sop.Friction;
+                physinfo["GravityMultiplier"] = sop.GravityModifier;
+                physinfo["Restitution"] = sop.Restitution;
+                physinfo["PhysicsShapeType"] = (int)sop.PhysicsShapeType;
+                array.Add(physinfo);
+            }
+
+            OSDMap llsdBody = new OSDMap(1);
+            llsdBody.Add("ObjectData", array);
+
+            eq.Enqueue(BuildEvent("ObjectPhysicsProperties", llsdBody),AgentId);
+*/
+        }
+
+
+        public void SendPartPhysicsProprieties(ISceneEntity entity)
+        {
+            SceneObjectPart part = (SceneObjectPart)entity;
+            if (part != null && AgentId != UUID.Zero)
+            {
+                try
+                {
+                    IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
+                    if (eq != null)
+                    {
+                        uint localid = part.LocalId;
+                        byte physshapetype = part.PhysicsShapeType;
+                        float density = part.Density;
+                        float friction = part.Friction;
+                        float bounce = part.Restitution;
+                        float gravmod = part.GravityModifier;
+
+                        eq.partPhysicsProperties(localid, physshapetype, density, friction, bounce, gravmod,AgentId);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    m_log.Error("Unable to send part Physics Proprieties - exception: " + ex.ToString());
+                }
+            }
+        }
+
+
+
+        public void SendGroupNameReply(UUID groupLLUID, string GroupName)
+        {
+            UUIDGroupNameReplyPacket pack = new UUIDGroupNameReplyPacket();
+            UUIDGroupNameReplyPacket.UUIDNameBlockBlock[] uidnameblock = new UUIDGroupNameReplyPacket.UUIDNameBlockBlock[1];
+            UUIDGroupNameReplyPacket.UUIDNameBlockBlock uidnamebloc = new UUIDGroupNameReplyPacket.UUIDNameBlockBlock();
+            uidnamebloc.ID = groupLLUID;
+            uidnamebloc.GroupName = Util.StringToBytes256(GroupName);
+            uidnameblock[0] = uidnamebloc;
+            pack.UUIDNameBlock = uidnameblock;
+            OutPacket(pack, ThrottleOutPacketType.Task);
+        }
+
+        public void SendLandStatReply(uint reportType, uint requestFlags, uint resultCount, LandStatReportItem[] lsrpia)
+        {
+            LandStatReplyPacket lsrp = new LandStatReplyPacket();
+            // LandStatReplyPacket.RequestDataBlock lsreqdpb = new LandStatReplyPacket.RequestDataBlock();
+            LandStatReplyPacket.ReportDataBlock[] lsrepdba = new LandStatReplyPacket.ReportDataBlock[lsrpia.Length];
+            //LandStatReplyPacket.ReportDataBlock lsrepdb = new LandStatReplyPacket.ReportDataBlock();
+            // lsrepdb.
+            lsrp.RequestData.ReportType = reportType;
+            lsrp.RequestData.RequestFlags = requestFlags;
+            lsrp.RequestData.TotalObjectCount = resultCount;
+            for (int i = 0; i < lsrpia.Length; i++)
+            {
+                LandStatReplyPacket.ReportDataBlock lsrepdb = new LandStatReplyPacket.ReportDataBlock();
+                lsrepdb.LocationX = lsrpia[i].LocationX;
+                lsrepdb.LocationY = lsrpia[i].LocationY;
+                lsrepdb.LocationZ = lsrpia[i].LocationZ;
+                lsrepdb.Score = lsrpia[i].Score;
+                lsrepdb.TaskID = lsrpia[i].TaskID;
+                lsrepdb.TaskLocalID = lsrpia[i].TaskLocalID;
+                lsrepdb.TaskName = Util.StringToBytes256(lsrpia[i].TaskName);
+                lsrepdb.OwnerName = Util.StringToBytes256(lsrpia[i].OwnerName);
+                lsrepdba[i] = lsrepdb;
+            }
+            lsrp.ReportData = lsrepdba;
+            OutPacket(lsrp, ThrottleOutPacketType.Task);
+        }
+
+        public void SendScriptRunningReply(UUID objectID, UUID itemID, bool running)
+        {
+            ScriptRunningReplyPacket scriptRunningReply = new ScriptRunningReplyPacket();
+            scriptRunningReply.Script.ObjectID = objectID;
+            scriptRunningReply.Script.ItemID = itemID;
+            scriptRunningReply.Script.Running = running;
+
+            OutPacket(scriptRunningReply, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAsset(AssetRequestToClient req)
+        {
+            if (req.AssetInf == null)
+            {
+                m_log.ErrorFormat("{0} Cannot send asset {1} ({2}), asset is null",
+                                LogHeader);
+                return;
+            }
+
+            if (req.AssetInf.Data == null)
+            {
+                m_log.ErrorFormat("{0} Cannot send asset {1} ({2}), asset data is null",
+                                LogHeader, req.AssetInf.ID, req.AssetInf.Metadata.ContentType);
+                return;
+            }
+
+            bool isWearable = false;
+
+            isWearable = ((AssetType) req.AssetInf.Type ==
+                     AssetType.Bodypart || (AssetType) req.AssetInf.Type == AssetType.Clothing);
+
+
+            //m_log.Debug("sending asset " + req.RequestAssetID + ", iswearable: " + isWearable);
+
+
+            //if (isWearable)
+            //    m_log.Debug((AssetType)req.AssetInf.Type);
+
+            TransferInfoPacket Transfer = new TransferInfoPacket();
+            Transfer.TransferInfo.ChannelType = 2;
+            Transfer.TransferInfo.Status = 0;
+            Transfer.TransferInfo.TargetType = 0;
+            if (req.AssetRequestSource == 2)
+            {
+                Transfer.TransferInfo.Params = new byte[20];
+                Array.Copy(req.RequestAssetID.GetBytes(), 0, Transfer.TransferInfo.Params, 0, 16);
+                int assType = req.AssetInf.Type;
+                Array.Copy(Utils.IntToBytes(assType), 0, Transfer.TransferInfo.Params, 16, 4);
+            }
+            else if (req.AssetRequestSource == 3)
+            {
+                Transfer.TransferInfo.Params = req.Params;
+                // Transfer.TransferInfo.Params = new byte[100];
+                //Array.Copy(req.RequestUser.AgentId.GetBytes(), 0, Transfer.TransferInfo.Params, 0, 16);
+                //Array.Copy(req.RequestUser.SessionId.GetBytes(), 0, Transfer.TransferInfo.Params, 16, 16);
+            }
+            Transfer.TransferInfo.Size = req.AssetInf.Data.Length;
+            Transfer.TransferInfo.TransferID = req.TransferRequestID;
+            Transfer.Header.Zerocoded = true;
+            OutPacket(Transfer, isWearable ? ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority : ThrottleOutPacketType.Asset);
+
+            if (req.NumPackets == 1)
+            {
+                TransferPacketPacket TransferPacket = new TransferPacketPacket();
+                TransferPacket.TransferData.Packet = 0;
+                TransferPacket.TransferData.ChannelType = 2;
+                TransferPacket.TransferData.TransferID = req.TransferRequestID;
+                TransferPacket.TransferData.Data = req.AssetInf.Data;
+                TransferPacket.TransferData.Status = 1;
+                TransferPacket.Header.Zerocoded = true;
+                OutPacket(TransferPacket, isWearable ? ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority : ThrottleOutPacketType.Asset);
+            }
+            else
+            {
+                int processedLength = 0;
+//                int maxChunkSize = Settings.MAX_PACKET_SIZE - 100;
+
+                int maxChunkSize = (int) MaxTransferBytesPerPacket;
+                int packetNumber = 0;
+
+                while (processedLength < req.AssetInf.Data.Length)
+                {
+                    TransferPacketPacket TransferPacket = new TransferPacketPacket();
+                    TransferPacket.TransferData.Packet = packetNumber;
+                    TransferPacket.TransferData.ChannelType = 2;
+                    TransferPacket.TransferData.TransferID = req.TransferRequestID;
+
+                    int chunkSize = Math.Min(req.AssetInf.Data.Length - processedLength, maxChunkSize);
+                    byte[] chunk = new byte[chunkSize];
+                    Array.Copy(req.AssetInf.Data, processedLength, chunk, 0, chunk.Length);
+
+                    TransferPacket.TransferData.Data = chunk;
+
+                    // 0 indicates more packets to come, 1 indicates last packet
+                    if (req.AssetInf.Data.Length - processedLength > maxChunkSize)
+                    {
+                        TransferPacket.TransferData.Status = 0;
+                    }
+                    else
+                    {
+                        TransferPacket.TransferData.Status = 1;
+                    }
+                    TransferPacket.Header.Zerocoded = true;
+                    OutPacket(TransferPacket, isWearable ? ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority : ThrottleOutPacketType.Asset);
+
+                    processedLength += chunkSize;
+                    packetNumber++;
+                }
+            }
+        }
+
+        public void SendAssetNotFound(AssetRequestToClient req)
+        {
+            TransferInfoPacket Transfer = new TransferInfoPacket();
+            Transfer.TransferInfo.ChannelType = 2;
+            Transfer.TransferInfo.Status = -2;
+            Transfer.TransferInfo.TargetType = 0;
+            Transfer.TransferInfo.Params = req.Params;
+            Transfer.TransferInfo.Size = 0;
+            Transfer.TransferInfo.TransferID = req.TransferRequestID;
+            Transfer.Header.Zerocoded = true;
+            OutPacket(Transfer, ThrottleOutPacketType.Asset);
+        }
+
+        public void SendTexture(AssetBase TextureAsset)
+        {
+
+        }
+
+        public void SendRegionHandle(UUID regionID, ulong handle)
+        {
+            RegionIDAndHandleReplyPacket reply = (RegionIDAndHandleReplyPacket)PacketPool.Instance.GetPacket(PacketType.RegionIDAndHandleReply);
+            reply.ReplyBlock.RegionID = regionID;
+            reply.ReplyBlock.RegionHandle = handle;
+            OutPacket(reply, ThrottleOutPacketType.Land);
+        }
+
+        public void SendParcelInfo(RegionInfo info, LandData land, UUID parcelID, uint x, uint y)
+        {
+            ParcelInfoReplyPacket reply = (ParcelInfoReplyPacket)PacketPool.Instance.GetPacket(PacketType.ParcelInfoReply);
+            reply.AgentData.AgentID = m_agentId;
+            reply.Data.ParcelID = parcelID;
+            reply.Data.OwnerID = land.OwnerID;
+            reply.Data.Name = Utils.StringToBytes(land.Name);
+            if (land.Description != null && land.Description != String.Empty)
+                reply.Data.Desc = Utils.StringToBytes(land.Description.Substring(0, land.Description.Length > 254 ? 254: land.Description.Length));
+            else
+                reply.Data.Desc = new Byte[0];
+            reply.Data.ActualArea = land.Area;
+            reply.Data.BillableArea = land.Area; // TODO: what is this?
+
+            reply.Data.Flags = (byte)Util.ConvertAccessLevelToMaturity((byte)info.AccessLevel);
+            if((land.Flags & (uint)ParcelFlags.ForSale) != 0)
+                reply.Data.Flags |= (byte)((1 << 7));
+
+            Vector3 pos = land.UserLocation;
+            if (pos.Equals(Vector3.Zero))
+            {
+                pos = (land.AABBMax + land.AABBMin) * 0.5f;
+            }
+            reply.Data.GlobalX = info.RegionLocX + x;
+            reply.Data.GlobalY = info.RegionLocY + y;
+            reply.Data.GlobalZ = pos.Z;
+            reply.Data.SimName = Utils.StringToBytes(info.RegionName);
+            reply.Data.SnapshotID = land.SnapshotID;
+            reply.Data.Dwell = land.Dwell;
+            reply.Data.SalePrice = land.SalePrice;
+            reply.Data.AuctionID = (int)land.AuctionID;
+
+            OutPacket(reply, ThrottleOutPacketType.Land);
+        }
+
+        public void SendScriptTeleportRequest(string objName, string simName, Vector3 pos, Vector3 lookAt)
+        {
+            ScriptTeleportRequestPacket packet = (ScriptTeleportRequestPacket)PacketPool.Instance.GetPacket(PacketType.ScriptTeleportRequest);
+
+            packet.Data.ObjectName = Utils.StringToBytes(objName);
+            packet.Data.SimName = Utils.StringToBytes(simName);
+            packet.Data.SimPosition = pos;
+            packet.Data.LookAt = lookAt;
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDirPlacesReply(UUID queryID, DirPlacesReplyData[] data)
+        {
+            DirPlacesReplyPacket packet = (DirPlacesReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirPlacesReply);
+
+            packet.AgentData = new DirPlacesReplyPacket.AgentDataBlock();
+
+            packet.QueryData = new DirPlacesReplyPacket.QueryDataBlock[1];
+            packet.QueryData[0] = new DirPlacesReplyPacket.QueryDataBlock();
+
+            packet.AgentData.AgentID = AgentId;
+
+            packet.QueryData[0].QueryID = queryID;
+
+            DirPlacesReplyPacket.QueryRepliesBlock[] replies =
+                    new DirPlacesReplyPacket.QueryRepliesBlock[0];
+            DirPlacesReplyPacket.StatusDataBlock[] status =
+                    new DirPlacesReplyPacket.StatusDataBlock[0];
+
+            packet.QueryReplies = replies;
+            packet.StatusData = status;
+
+            foreach (DirPlacesReplyData d in data)
+            {
+                int idx = replies.Length;
+                Array.Resize(ref replies, idx + 1);
+                Array.Resize(ref status, idx + 1);
+
+                replies[idx] = new DirPlacesReplyPacket.QueryRepliesBlock();
+                status[idx] = new DirPlacesReplyPacket.StatusDataBlock();
+                replies[idx].ParcelID = d.parcelID;
+                replies[idx].Name = Utils.StringToBytes(d.name);
+                replies[idx].ForSale = d.forSale;
+                replies[idx].Auction = d.auction;
+                replies[idx].Dwell = d.dwell;
+                status[idx].Status = d.Status;
+
+                packet.QueryReplies = replies;
+                packet.StatusData = status;
+
+                if (packet.Length >= 1000)
+                {
+                    OutPacket(packet, ThrottleOutPacketType.Task);
+
+                    packet = (DirPlacesReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirPlacesReply);
+
+                    packet.AgentData = new DirPlacesReplyPacket.AgentDataBlock();
+
+                    packet.QueryData = new DirPlacesReplyPacket.QueryDataBlock[1];
+                    packet.QueryData[0] = new DirPlacesReplyPacket.QueryDataBlock();
+
+                    packet.AgentData.AgentID = AgentId;
+
+                    packet.QueryData[0].QueryID = queryID;
+
+                    replies = new DirPlacesReplyPacket.QueryRepliesBlock[0];
+                    status = new DirPlacesReplyPacket.StatusDataBlock[0];
+                }
+            }
+
+            if (replies.Length > 0 || data.Length == 0)
+                OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDirPeopleReply(UUID queryID, DirPeopleReplyData[] data)
+        {
+            DirPeopleReplyPacket packet = (DirPeopleReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirPeopleReply);
+
+            packet.AgentData = new DirPeopleReplyPacket.AgentDataBlock();
+            packet.AgentData.AgentID = AgentId;
+
+            packet.QueryData = new DirPeopleReplyPacket.QueryDataBlock();
+            packet.QueryData.QueryID = queryID;
+
+            packet.QueryReplies = new DirPeopleReplyPacket.QueryRepliesBlock[
+                    data.Length];
+
+            int i = 0;
+            foreach (DirPeopleReplyData d in data)
+            {
+                packet.QueryReplies[i] = new DirPeopleReplyPacket.QueryRepliesBlock();
+                packet.QueryReplies[i].AgentID = d.agentID;
+                packet.QueryReplies[i].FirstName =
+                        Utils.StringToBytes(d.firstName);
+                packet.QueryReplies[i].LastName =
+                        Utils.StringToBytes(d.lastName);
+                packet.QueryReplies[i].Group =
+                        Utils.StringToBytes(d.group);
+                packet.QueryReplies[i].Online = d.online;
+                packet.QueryReplies[i].Reputation = d.reputation;
+                i++;
+            }
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDirEventsReply(UUID queryID, DirEventsReplyData[] data)
+        {
+            DirEventsReplyPacket packet = (DirEventsReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirEventsReply);
+
+            packet.AgentData = new DirEventsReplyPacket.AgentDataBlock();
+            packet.AgentData.AgentID = AgentId;
+
+            packet.QueryData = new DirEventsReplyPacket.QueryDataBlock();
+            packet.QueryData.QueryID = queryID;
+
+            packet.QueryReplies = new DirEventsReplyPacket.QueryRepliesBlock[
+                    data.Length];
+
+            packet.StatusData = new DirEventsReplyPacket.StatusDataBlock[
+                    data.Length];
+
+            int i = 0;
+            foreach (DirEventsReplyData d in data)
+            {
+                packet.QueryReplies[i] = new DirEventsReplyPacket.QueryRepliesBlock();
+                packet.StatusData[i] = new DirEventsReplyPacket.StatusDataBlock();
+                packet.QueryReplies[i].OwnerID = d.ownerID;
+                packet.QueryReplies[i].Name =
+                        Utils.StringToBytes(d.name);
+                packet.QueryReplies[i].EventID = d.eventID;
+                packet.QueryReplies[i].Date =
+                        Utils.StringToBytes(d.date);
+                packet.QueryReplies[i].UnixTime = d.unixTime;
+                packet.QueryReplies[i].EventFlags = d.eventFlags;
+                packet.StatusData[i].Status = d.Status;
+                i++;
+            }
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDirGroupsReply(UUID queryID, DirGroupsReplyData[] data)
+        {
+            DirGroupsReplyPacket packet = (DirGroupsReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirGroupsReply);
+
+            packet.AgentData = new DirGroupsReplyPacket.AgentDataBlock();
+            packet.AgentData.AgentID = AgentId;
+
+            packet.QueryData = new DirGroupsReplyPacket.QueryDataBlock();
+            packet.QueryData.QueryID = queryID;
+
+            packet.QueryReplies = new DirGroupsReplyPacket.QueryRepliesBlock[
+                    data.Length];
+
+            int i = 0;
+            foreach (DirGroupsReplyData d in data)
+            {
+                packet.QueryReplies[i] = new DirGroupsReplyPacket.QueryRepliesBlock();
+                packet.QueryReplies[i].GroupID = d.groupID;
+                packet.QueryReplies[i].GroupName =
+                        Utils.StringToBytes(d.groupName);
+                packet.QueryReplies[i].Members = d.members;
+                packet.QueryReplies[i].SearchOrder = d.searchOrder;
+                i++;
+            }
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDirClassifiedReply(UUID queryID, DirClassifiedReplyData[] data)
+        {
+            DirClassifiedReplyPacket packet = (DirClassifiedReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirClassifiedReply);
+
+            packet.AgentData = new DirClassifiedReplyPacket.AgentDataBlock();
+            packet.AgentData.AgentID = AgentId;
+
+            packet.QueryData = new DirClassifiedReplyPacket.QueryDataBlock();
+            packet.QueryData.QueryID = queryID;
+
+            packet.QueryReplies = new DirClassifiedReplyPacket.QueryRepliesBlock[
+                    data.Length];
+            packet.StatusData = new DirClassifiedReplyPacket.StatusDataBlock[
+                    data.Length];
+
+            int i = 0;
+            foreach (DirClassifiedReplyData d in data)
+            {
+                packet.QueryReplies[i] = new DirClassifiedReplyPacket.QueryRepliesBlock();
+                packet.StatusData[i] = new DirClassifiedReplyPacket.StatusDataBlock();
+                packet.QueryReplies[i].ClassifiedID = d.classifiedID;
+                packet.QueryReplies[i].Name =
+                        Utils.StringToBytes(d.name);
+                packet.QueryReplies[i].ClassifiedFlags = d.classifiedFlags;
+                packet.QueryReplies[i].CreationDate = d.creationDate;
+                packet.QueryReplies[i].ExpirationDate = d.expirationDate;
+                packet.QueryReplies[i].PriceForListing = d.price;
+                packet.StatusData[i].Status = d.Status;
+                i++;
+            }
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDirLandReply(UUID queryID, DirLandReplyData[] data)
+        {
+            DirLandReplyPacket packet = (DirLandReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirLandReply);
+
+            packet.AgentData = new DirLandReplyPacket.AgentDataBlock();
+            packet.AgentData.AgentID = AgentId;
+
+            packet.QueryData = new DirLandReplyPacket.QueryDataBlock();
+            packet.QueryData.QueryID = queryID;
+
+            packet.QueryReplies = new DirLandReplyPacket.QueryRepliesBlock[
+                    data.Length];
+
+            int i = 0;
+            foreach (DirLandReplyData d in data)
+            {
+                packet.QueryReplies[i] = new DirLandReplyPacket.QueryRepliesBlock();
+                packet.QueryReplies[i].ParcelID = d.parcelID;
+                packet.QueryReplies[i].Name =
+                        Utils.StringToBytes(d.name);
+                packet.QueryReplies[i].Auction = d.auction;
+                packet.QueryReplies[i].ForSale = d.forSale;
+                packet.QueryReplies[i].SalePrice = d.salePrice;
+                packet.QueryReplies[i].ActualArea = d.actualArea;
+                i++;
+            }
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDirPopularReply(UUID queryID, DirPopularReplyData[] data)
+        {
+            DirPopularReplyPacket packet = (DirPopularReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirPopularReply);
+
+            packet.AgentData = new DirPopularReplyPacket.AgentDataBlock();
+            packet.AgentData.AgentID = AgentId;
+
+            packet.QueryData = new DirPopularReplyPacket.QueryDataBlock();
+            packet.QueryData.QueryID = queryID;
+
+            packet.QueryReplies = new DirPopularReplyPacket.QueryRepliesBlock[
+                    data.Length];
+
+            int i = 0;
+            foreach (DirPopularReplyData d in data)
+            {
+                packet.QueryReplies[i] = new DirPopularReplyPacket.QueryRepliesBlock();
+                packet.QueryReplies[i].ParcelID = d.parcelID;
+                packet.QueryReplies[i].Name =
+                        Utils.StringToBytes(d.name);
+                packet.QueryReplies[i].Dwell = d.dwell;
+                i++;
+            }
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendEventInfoReply(EventData data)
+        {
+            EventInfoReplyPacket packet = (EventInfoReplyPacket)PacketPool.Instance.GetPacket(PacketType.EventInfoReply);
+
+            packet.AgentData = new EventInfoReplyPacket.AgentDataBlock();
+            packet.AgentData.AgentID = AgentId;
+
+            packet.EventData = new EventInfoReplyPacket.EventDataBlock();
+            packet.EventData.EventID = data.eventID;
+            packet.EventData.Creator = Utils.StringToBytes(data.creator);
+            packet.EventData.Name = Utils.StringToBytes(data.name);
+            packet.EventData.Category = Utils.StringToBytes(data.category);
+            packet.EventData.Desc = Utils.StringToBytes(data.description);
+            packet.EventData.Date = Utils.StringToBytes(data.date);
+            packet.EventData.DateUTC = data.dateUTC;
+            packet.EventData.Duration = data.duration;
+            packet.EventData.Cover = data.cover;
+            packet.EventData.Amount = data.amount;
+            packet.EventData.SimName = Utils.StringToBytes(data.simName);
+            packet.EventData.GlobalPos = new Vector3d(data.globalPos);
+            packet.EventData.EventFlags = data.eventFlags;
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendMapItemReply(mapItemReply[] replies, uint mapitemtype, uint flags)
+        {
+            MapItemReplyPacket mirplk = new MapItemReplyPacket();
+            mirplk.AgentData.AgentID = AgentId;
+            mirplk.RequestData.ItemType = mapitemtype;
+            mirplk.Data = new MapItemReplyPacket.DataBlock[replies.Length];
+            for (int i = 0; i < replies.Length; i++)
+            {
+                MapItemReplyPacket.DataBlock mrdata = new MapItemReplyPacket.DataBlock();
+                mrdata.X = replies[i].x;
+                mrdata.Y = replies[i].y;
+                mrdata.ID = replies[i].id;
+                mrdata.Extra = replies[i].Extra;
+                mrdata.Extra2 = replies[i].Extra2;
+                mrdata.Name = Utils.StringToBytes(replies[i].name);
+                mirplk.Data[i] = mrdata;
+            }
+            //m_log.Debug(mirplk.ToString());
+            OutPacket(mirplk, ThrottleOutPacketType.Task);
+
+        }
+
+        public void SendOfferCallingCard(UUID srcID, UUID transactionID)
+        {
+            // a bit special, as this uses AgentID to store the source instead
+            // of the destination. The destination (the receiver) goes into destID
+            OfferCallingCardPacket p = (OfferCallingCardPacket)PacketPool.Instance.GetPacket(PacketType.OfferCallingCard);
+            p.AgentData.AgentID = srcID;
+            p.AgentData.SessionID = UUID.Zero;
+            p.AgentBlock.DestID = AgentId;
+            p.AgentBlock.TransactionID = transactionID;
+            OutPacket(p, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAcceptCallingCard(UUID transactionID)
+        {
+            AcceptCallingCardPacket p = (AcceptCallingCardPacket)PacketPool.Instance.GetPacket(PacketType.AcceptCallingCard);
+            p.AgentData.AgentID = AgentId;
+            p.AgentData.SessionID = UUID.Zero;
+            p.FolderData = new AcceptCallingCardPacket.FolderDataBlock[1];
+            p.FolderData[0] = new AcceptCallingCardPacket.FolderDataBlock();
+            p.FolderData[0].FolderID = UUID.Zero;
+            OutPacket(p, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDeclineCallingCard(UUID transactionID)
+        {
+            DeclineCallingCardPacket p = (DeclineCallingCardPacket)PacketPool.Instance.GetPacket(PacketType.DeclineCallingCard);
+            p.AgentData.AgentID = AgentId;
+            p.AgentData.SessionID = UUID.Zero;
+            p.TransactionBlock.TransactionID = transactionID;
+            OutPacket(p, ThrottleOutPacketType.Task);
+        }
+
+        public void SendTerminateFriend(UUID exFriendID)
+        {
+            TerminateFriendshipPacket p = (TerminateFriendshipPacket)PacketPool.Instance.GetPacket(PacketType.TerminateFriendship);
+            p.AgentData.AgentID = AgentId;
+            p.AgentData.SessionID = SessionId;
+            p.ExBlock.OtherID = exFriendID;
+            OutPacket(p, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAvatarGroupsReply(UUID avatarID, GroupMembershipData[] data)
+        {
+             OSDMap llsd = new OSDMap(3);
+             OSDArray AgentData = new OSDArray(1);
+             OSDMap AgentDataMap = new OSDMap(1);
+             AgentDataMap.Add("AgentID", OSD.FromUUID(this.AgentId));
+             AgentDataMap.Add("AvatarID", OSD.FromUUID(avatarID));
+             AgentData.Add(AgentDataMap);
+             llsd.Add("AgentData", AgentData);
+             OSDArray GroupData = new OSDArray(data.Length);
+//             OSDArray NewGroupData = new OSDArray(data.Length);
+             foreach (GroupMembershipData m in data)
+             {
+                 OSDMap GroupDataMap = new OSDMap(6);
+                 OSDMap NewGroupDataMap = new OSDMap(1);
+                 GroupDataMap.Add("GroupPowers", OSD.FromULong(m.GroupPowers));
+                 GroupDataMap.Add("AcceptNotices", OSD.FromBoolean(m.AcceptNotices));
+                 GroupDataMap.Add("GroupTitle", OSD.FromString(m.GroupTitle));
+                 GroupDataMap.Add("GroupID", OSD.FromUUID(m.GroupID));
+                 GroupDataMap.Add("GroupName", OSD.FromString(m.GroupName));
+                 GroupDataMap.Add("GroupInsigniaID", OSD.FromUUID(m.GroupPicture));
+//                 NewGroupDataMap.Add("ListInProfile", OSD.FromBoolean(m.ListInProfile));
+                 GroupData.Add(GroupDataMap);
+//                 NewGroupData.Add(NewGroupDataMap);
+             }
+             llsd.Add("GroupData", GroupData);
+ //            llsd.Add("NewGroupData", NewGroupData);
+
+             IEventQueue eq = this.Scene.RequestModuleInterface<IEventQueue>();
+             if (eq != null)
+             {
+                 eq.Enqueue(BuildEvent("AvatarGroupsReply", llsd), this.AgentId);
+             }
+        }
+
+        public void SendAgentGroupDataUpdate(UUID avatarID, GroupMembershipData[] data)
+        {
+            if(avatarID != AgentId)
+                m_log.Debug("[CLIENT]: SendAgentGroupDataUpdate avatarID != AgentId");
+
+            IEventQueue eq = this.Scene.RequestModuleInterface<IEventQueue>();
+            if(eq != null)
+            {
+                eq.GroupMembershipData(avatarID,data);
+            }
+            else
+            {
+                // use UDP if no caps
+                AgentGroupDataUpdatePacket Groupupdate = new AgentGroupDataUpdatePacket();
+                AgentGroupDataUpdatePacket.GroupDataBlock[] Groups = new AgentGroupDataUpdatePacket.GroupDataBlock[data.Length];
+                for (int i = 0; i < data.Length; i++)
+                {
+                    AgentGroupDataUpdatePacket.GroupDataBlock Group = new AgentGroupDataUpdatePacket.GroupDataBlock();
+                    Group.AcceptNotices = data[i].AcceptNotices;
+                    Group.Contribution = data[i].Contribution;
+                    Group.GroupID = data[i].GroupID;
+                    Group.GroupInsigniaID = data[i].GroupPicture;
+                    Group.GroupName = Util.StringToBytes256(data[i].GroupName);
+                    Group.GroupPowers = data[i].GroupPowers;
+                    Groups[i] = Group;
+                }
+                Groupupdate.GroupData = Groups;
+                Groupupdate.AgentData = new AgentGroupDataUpdatePacket.AgentDataBlock();
+                Groupupdate.AgentData.AgentID = avatarID;
+                OutPacket(Groupupdate, ThrottleOutPacketType.Task);
+            }
+        }
+
+        public void SendJoinGroupReply(UUID groupID, bool success)
+        {
+            JoinGroupReplyPacket p = (JoinGroupReplyPacket)PacketPool.Instance.GetPacket(PacketType.JoinGroupReply);
+
+            p.AgentData = new JoinGroupReplyPacket.AgentDataBlock();
+            p.AgentData.AgentID = AgentId;
+
+            p.GroupData = new JoinGroupReplyPacket.GroupDataBlock();
+            p.GroupData.GroupID = groupID;
+            p.GroupData.Success = success;
+
+            OutPacket(p, ThrottleOutPacketType.Task);
+        }
+
+        public void SendEjectGroupMemberReply(UUID agentID, UUID groupID, bool success)
+        {
+            EjectGroupMemberReplyPacket p = (EjectGroupMemberReplyPacket)PacketPool.Instance.GetPacket(PacketType.EjectGroupMemberReply);
+
+            p.AgentData = new EjectGroupMemberReplyPacket.AgentDataBlock();
+            p.AgentData.AgentID = agentID;
+
+            p.GroupData = new EjectGroupMemberReplyPacket.GroupDataBlock();
+            p.GroupData.GroupID = groupID;
+
+            p.EjectData = new EjectGroupMemberReplyPacket.EjectDataBlock();
+            p.EjectData.Success = success;
+
+            OutPacket(p, ThrottleOutPacketType.Task);
+        }
+
+        public void SendLeaveGroupReply(UUID groupID, bool success)
+        {
+            LeaveGroupReplyPacket p = (LeaveGroupReplyPacket)PacketPool.Instance.GetPacket(PacketType.LeaveGroupReply);
+
+            p.AgentData = new LeaveGroupReplyPacket.AgentDataBlock();
+            p.AgentData.AgentID = AgentId;
+
+            p.GroupData = new LeaveGroupReplyPacket.GroupDataBlock();
+            p.GroupData.GroupID = groupID;
+            p.GroupData.Success = success;
+
+            OutPacket(p, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAvatarClassifiedReply(UUID targetID, UUID[] classifiedID, string[] name)
+        {
+            if (classifiedID.Length != name.Length)
+                return;
+
+            AvatarClassifiedReplyPacket ac =
+                    (AvatarClassifiedReplyPacket)PacketPool.Instance.GetPacket(
+                    PacketType.AvatarClassifiedReply);
+
+            ac.AgentData = new AvatarClassifiedReplyPacket.AgentDataBlock();
+            ac.AgentData.AgentID = AgentId;
+            ac.AgentData.TargetID = targetID;
+
+            ac.Data = new AvatarClassifiedReplyPacket.DataBlock[classifiedID.Length];
+            int i;
+            for (i = 0; i < classifiedID.Length; i++)
+            {
+                ac.Data[i].ClassifiedID = classifiedID[i];
+                ac.Data[i].Name = Utils.StringToBytes(name[i]);
+            }
+
+            OutPacket(ac, ThrottleOutPacketType.Task);
+        }
+
+        public void SendClassifiedInfoReply(UUID classifiedID, UUID creatorID, uint creationDate, uint expirationDate, uint category, string name, string description, UUID parcelID, uint parentEstate, UUID snapshotID, string simName, Vector3 globalPos, string parcelName, byte classifiedFlags, int price)
+        {
+            ClassifiedInfoReplyPacket cr =
+                    (ClassifiedInfoReplyPacket)PacketPool.Instance.GetPacket(
+                    PacketType.ClassifiedInfoReply);
+
+            cr.AgentData = new ClassifiedInfoReplyPacket.AgentDataBlock();
+            cr.AgentData.AgentID = AgentId;
+
+            cr.Data = new ClassifiedInfoReplyPacket.DataBlock();
+            cr.Data.ClassifiedID = classifiedID;
+            cr.Data.CreatorID = creatorID;
+            cr.Data.CreationDate = creationDate;
+            cr.Data.ExpirationDate = expirationDate;
+            cr.Data.Category = category;
+            cr.Data.Name = Utils.StringToBytes(name);
+            cr.Data.Desc = Utils.StringToBytes(description);
+            cr.Data.ParcelID = parcelID;
+            cr.Data.ParentEstate = parentEstate;
+            cr.Data.SnapshotID = snapshotID;
+            cr.Data.SimName = Utils.StringToBytes(simName);
+            cr.Data.PosGlobal = new Vector3d(globalPos);
+            cr.Data.ParcelName = Utils.StringToBytes(parcelName);
+            cr.Data.ClassifiedFlags = classifiedFlags;
+            cr.Data.PriceForListing = price;
+
+            OutPacket(cr, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAgentDropGroup(UUID groupID)
+        {
+            AgentDropGroupPacket dg =
+                    (AgentDropGroupPacket)PacketPool.Instance.GetPacket(
+                    PacketType.AgentDropGroup);
+
+            dg.AgentData = new AgentDropGroupPacket.AgentDataBlock();
+            dg.AgentData.AgentID = AgentId;
+            dg.AgentData.GroupID = groupID;
+
+            OutPacket(dg, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAvatarNotesReply(UUID targetID, string text)
+        {
+            AvatarNotesReplyPacket an =
+                    (AvatarNotesReplyPacket)PacketPool.Instance.GetPacket(
+                    PacketType.AvatarNotesReply);
+
+            an.AgentData = new AvatarNotesReplyPacket.AgentDataBlock();
+            an.AgentData.AgentID = AgentId;
+
+            an.Data = new AvatarNotesReplyPacket.DataBlock();
+            an.Data.TargetID = targetID;
+            an.Data.Notes = Utils.StringToBytes(text);
+
+            OutPacket(an, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAvatarPicksReply(UUID targetID, Dictionary<UUID, string> picks)
+        {
+            AvatarPicksReplyPacket ap =
+                    (AvatarPicksReplyPacket)PacketPool.Instance.GetPacket(
+                    PacketType.AvatarPicksReply);
+
+            ap.AgentData = new AvatarPicksReplyPacket.AgentDataBlock();
+            ap.AgentData.AgentID = AgentId;
+            ap.AgentData.TargetID = targetID;
+
+            ap.Data = new AvatarPicksReplyPacket.DataBlock[picks.Count];
+
+            int i = 0;
+            foreach (KeyValuePair<UUID, string> pick in picks)
+            {
+                ap.Data[i] = new AvatarPicksReplyPacket.DataBlock();
+                ap.Data[i].PickID = pick.Key;
+                ap.Data[i].PickName = Utils.StringToBytes(pick.Value);
+                i++;
+            }
+
+            OutPacket(ap, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAvatarClassifiedReply(UUID targetID, Dictionary<UUID, string> classifieds)
+        {
+            AvatarClassifiedReplyPacket ac =
+                    (AvatarClassifiedReplyPacket)PacketPool.Instance.GetPacket(
+                    PacketType.AvatarClassifiedReply);
+
+            ac.AgentData = new AvatarClassifiedReplyPacket.AgentDataBlock();
+            ac.AgentData.AgentID = AgentId;
+            ac.AgentData.TargetID = targetID;
+
+            ac.Data = new AvatarClassifiedReplyPacket.DataBlock[classifieds.Count];
+
+            int i = 0;
+            foreach (KeyValuePair<UUID, string> classified in classifieds)
+            {
+                ac.Data[i] = new AvatarClassifiedReplyPacket.DataBlock();
+                ac.Data[i].ClassifiedID = classified.Key;
+                ac.Data[i].Name = Utils.StringToBytes(classified.Value);
+                i++;
+            }
+
+            OutPacket(ac, ThrottleOutPacketType.Task);
+        }
+
+        public void SendParcelDwellReply(int localID, UUID parcelID, float dwell)
+        {
+            ParcelDwellReplyPacket pd =
+                    (ParcelDwellReplyPacket)PacketPool.Instance.GetPacket(
+                    PacketType.ParcelDwellReply);
+
+            pd.AgentData = new ParcelDwellReplyPacket.AgentDataBlock();
+            pd.AgentData.AgentID = AgentId;
+
+            pd.Data = new ParcelDwellReplyPacket.DataBlock();
+            pd.Data.LocalID = localID;
+            pd.Data.ParcelID = parcelID;
+            pd.Data.Dwell = dwell;
+
+            OutPacket(pd, ThrottleOutPacketType.Land);
+        }
+
+        public void SendUserInfoReply(bool imViaEmail, bool visible, string email)
+        {
+            UserInfoReplyPacket ur =
+                    (UserInfoReplyPacket)PacketPool.Instance.GetPacket(
+                    PacketType.UserInfoReply);
+
+            string Visible = "hidden";
+            if (visible)
+                Visible = "default";
+
+            ur.AgentData = new UserInfoReplyPacket.AgentDataBlock();
+            ur.AgentData.AgentID = AgentId;
+
+            ur.UserData = new UserInfoReplyPacket.UserDataBlock();
+            ur.UserData.IMViaEMail = imViaEmail;
+            ur.UserData.DirectoryVisibility = Utils.StringToBytes(Visible);
+            ur.UserData.EMail = Utils.StringToBytes(email);
+
+            OutPacket(ur, ThrottleOutPacketType.Task);
+        }
+
+        public void SendCreateGroupReply(UUID groupID, bool success, string message)
+        {
+            CreateGroupReplyPacket createGroupReply = (CreateGroupReplyPacket)PacketPool.Instance.GetPacket(PacketType.CreateGroupReply);
+
+            createGroupReply.AgentData =
+                new CreateGroupReplyPacket.AgentDataBlock();
+            createGroupReply.ReplyData =
+                new CreateGroupReplyPacket.ReplyDataBlock();
+
+            createGroupReply.AgentData.AgentID = AgentId;
+            createGroupReply.ReplyData.GroupID = groupID;
+
+            createGroupReply.ReplyData.Success = success;
+            createGroupReply.ReplyData.Message = Utils.StringToBytes(message);
+            OutPacket(createGroupReply, ThrottleOutPacketType.Task);
+        }
+
+        public void SendUseCachedMuteList()
+        {
+            UseCachedMuteListPacket useCachedMuteList = (UseCachedMuteListPacket)PacketPool.Instance.GetPacket(PacketType.UseCachedMuteList);
+
+            useCachedMuteList.AgentData = new UseCachedMuteListPacket.AgentDataBlock();
+            useCachedMuteList.AgentData.AgentID = AgentId;
+
+            OutPacket(useCachedMuteList, ThrottleOutPacketType.Task);
+        }
+
+       public void SendEmpytMuteList()
+        {
+            GenericMessagePacket gmp = new GenericMessagePacket();
+
+            gmp.AgentData.AgentID = AgentId;
+            gmp.AgentData.SessionID = m_sessionId;
+            gmp.AgentData.TransactionID = UUID.Zero;
+
+            gmp.MethodData.Method = Util.StringToBytes256("emptymutelist");
+            gmp.ParamList = new GenericMessagePacket.ParamListBlock[1];
+            gmp.ParamList[0] = new GenericMessagePacket.ParamListBlock();
+            gmp.ParamList[0].Parameter = new byte[0];
+
+            OutPacket(gmp, ThrottleOutPacketType.Task);
+        }
+
+        public void SendMuteListUpdate(string filename)
+        {
+            MuteListUpdatePacket muteListUpdate = (MuteListUpdatePacket)PacketPool.Instance.GetPacket(PacketType.MuteListUpdate);
+
+            muteListUpdate.MuteData = new MuteListUpdatePacket.MuteDataBlock();
+            muteListUpdate.MuteData.AgentID = AgentId;
+            muteListUpdate.MuteData.Filename = Utils.StringToBytes(filename);
+
+            OutPacket(muteListUpdate, ThrottleOutPacketType.Task);
+        }
+
+        public void SendPickInfoReply(UUID pickID, UUID creatorID, bool topPick, UUID parcelID, string name, string desc, UUID snapshotID, string user, string originalName, string simName, Vector3 posGlobal, int sortOrder, bool enabled)
+        {
+            PickInfoReplyPacket pickInfoReply = (PickInfoReplyPacket)PacketPool.Instance.GetPacket(PacketType.PickInfoReply);
+
+            pickInfoReply.AgentData = new PickInfoReplyPacket.AgentDataBlock();
+            pickInfoReply.AgentData.AgentID = AgentId;
+
+            pickInfoReply.Data = new PickInfoReplyPacket.DataBlock();
+            pickInfoReply.Data.PickID = pickID;
+            pickInfoReply.Data.CreatorID = creatorID;
+            pickInfoReply.Data.TopPick = topPick;
+            pickInfoReply.Data.ParcelID = parcelID;
+            pickInfoReply.Data.Name = Utils.StringToBytes(name);
+            pickInfoReply.Data.Desc = Utils.StringToBytes(desc);
+            pickInfoReply.Data.SnapshotID = snapshotID;
+            pickInfoReply.Data.User = Utils.StringToBytes(user);
+            pickInfoReply.Data.OriginalName = Utils.StringToBytes(originalName);
+            pickInfoReply.Data.SimName = Utils.StringToBytes(simName);
+            pickInfoReply.Data.PosGlobal = new Vector3d(posGlobal);
+            pickInfoReply.Data.SortOrder = sortOrder;
+            pickInfoReply.Data.Enabled = enabled;
+
+            OutPacket(pickInfoReply, ThrottleOutPacketType.Task);
+        }
+
+        #endregion Scene/Avatar to Client
+
+        // Gesture
+
+        #region Appearance/ Wearables Methods
+
+        public void SendWearables(AvatarWearable[] wearables, int serial)
+        {
+            AgentWearablesUpdatePacket aw = (AgentWearablesUpdatePacket)PacketPool.Instance.GetPacket(PacketType.AgentWearablesUpdate);
+            aw.AgentData.AgentID = AgentId;
+            aw.AgentData.SerialNum = (uint)serial;
+            aw.AgentData.SessionID = m_sessionId;
+
+            int count = 0;
+            for (int i = 0; i < wearables.Length; i++)
+                count += wearables[i].Count;
+
+            // TODO: don't create new blocks if recycling an old packet
+            aw.WearableData = new AgentWearablesUpdatePacket.WearableDataBlock[count];
+            AgentWearablesUpdatePacket.WearableDataBlock awb;
+            int idx = 0;
+
+                    for (int i = 0; i < wearables.Length; i++)
+                    {
+                        for (int j = 0; j < wearables[i].Count; j++)
+                        {
+                            awb = new AgentWearablesUpdatePacket.WearableDataBlock();
+                            awb.WearableType = (byte) i;
+                            awb.AssetID = wearables[i][j].AssetID;
+                            awb.ItemID = wearables[i][j].ItemID;
+                            aw.WearableData[idx] = awb;
+                            idx++;
+
+                            //                                m_log.DebugFormat(
+                            //                                    "[APPEARANCE]: Sending wearable item/asset {0} {1} (index {2}) for {3}",
+                            //                                    awb.ItemID, awb.AssetID, i, Name);
+                        }
+                    }
+
+            OutPacket(aw, ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority);
+        }
+
+        public void SendAppearance(UUID agentID, byte[] visualParams, byte[] textureEntry)
+        {
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Sending avatar appearance for {0} with {1} bytes to {2} {3}",
+//                agentID, textureEntry.Length, Name, AgentId);
+
+            AvatarAppearancePacket avp = (AvatarAppearancePacket)PacketPool.Instance.GetPacket(PacketType.AvatarAppearance);
+            // TODO: don't create new blocks if recycling an old packet
+            avp.VisualParam = new AvatarAppearancePacket.VisualParamBlock[visualParams.Length];
+            avp.ObjectData.TextureEntry = textureEntry;
+
+            AvatarAppearancePacket.VisualParamBlock avblock = null;
+            for (int i = 0; i < visualParams.Length; i++)
+            {
+                avblock = new AvatarAppearancePacket.VisualParamBlock();
+                avblock.ParamValue = visualParams[i];
+                avp.VisualParam[i] = avblock;
+            }
+
+            avp.Sender.IsTrial = false;
+            avp.Sender.ID = agentID;
+            avp.AppearanceData = new AvatarAppearancePacket.AppearanceDataBlock[0];
+            avp.AppearanceHover = new AvatarAppearancePacket.AppearanceHoverBlock[0];
+
+// this need be use in future ?
+//           avp.AppearanceData[0].AppearanceVersion = 0;
+//           avp.AppearanceData[0].CofVersion = 0;
+
+            //m_log.DebugFormat("[CLIENT]: Sending appearance for {0} to {1}", agentID.ToString(), AgentId.ToString());
+            OutPacket(avp, ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority);
+        }
+
+        public void SendAnimations(UUID[] animations, int[] seqs, UUID sourceAgentId, UUID[] objectIDs)
+        {
+//            m_log.DebugFormat("[LLCLIENTVIEW]: Sending animations for {0} to {1}", sourceAgentId, Name);
+
+            AvatarAnimationPacket ani = (AvatarAnimationPacket)PacketPool.Instance.GetPacket(PacketType.AvatarAnimation);
+            // TODO: don't create new blocks if recycling an old packet
+            ani.AnimationSourceList = new AvatarAnimationPacket.AnimationSourceListBlock[animations.Length];
+            ani.Sender = new AvatarAnimationPacket.SenderBlock();
+            ani.Sender.ID = sourceAgentId;
+            ani.AnimationList = new AvatarAnimationPacket.AnimationListBlock[animations.Length];
+            ani.PhysicalAvatarEventList = new AvatarAnimationPacket.PhysicalAvatarEventListBlock[0];
+
+            for (int i = 0; i < animations.Length; ++i)
+            {
+                ani.AnimationList[i] = new AvatarAnimationPacket.AnimationListBlock();
+                ani.AnimationList[i].AnimID = animations[i];
+                ani.AnimationList[i].AnimSequenceID = seqs[i];
+
+                ani.AnimationSourceList[i] = new AvatarAnimationPacket.AnimationSourceListBlock();
+                if (objectIDs[i].Equals(sourceAgentId))
+                    ani.AnimationSourceList[i].ObjectID = UUID.Zero;
+                else
+                    ani.AnimationSourceList[i].ObjectID = objectIDs[i];
+            }
+            ani.Header.Reliable = false;
+            OutPacket(ani, ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority);
+        }
+
+        #endregion
+
+        #region Avatar Packet/Data Sending Methods
+
+        /// <summary>
+        /// Send an ObjectUpdate packet with information about an avatar
+        /// </summary>
+        public void SendEntityFullUpdateImmediate(ISceneEntity ent)
+        {
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Sending immediate object update for avatar {0} {1} to {2} {3}",
+//                avatar.Name, avatar.UUID, Name, AgentId);
+
+            if (ent == null)
+                return;
+
+            ObjectUpdatePacket objupdate = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);
+            objupdate.Header.Zerocoded = true;
+
+            objupdate.RegionData.TimeDilation = Utils.FloatToUInt16(m_scene.TimeDilation, 0.0f, 1.0f);
+            objupdate.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
+
+            if(ent is ScenePresence)
+            {
+                ScenePresence presence = ent as ScenePresence;
+                objupdate.RegionData.RegionHandle = presence.RegionHandle;
+                objupdate.ObjectData[0] = CreateAvatarUpdateBlock(presence);
+            }
+            else if(ent is SceneObjectPart)
+            {
+                SceneObjectPart part = ent  as SceneObjectPart;
+                objupdate.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                objupdate.ObjectData[0] = CreatePrimUpdateBlock(part,  (ScenePresence)SceneAgent);
+            }
+
+            OutPacket(objupdate, ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority);
+
+            // We need to record the avatar local id since the root prim of an attachment points to this.
+//            m_attachmentsSent.Add(avatar.LocalId);
+        }
+
+        public void SendEntityTerseUpdateImmediate(ISceneEntity ent)
+        {
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Sending immediate object update for avatar {0} {1} to {2} {3}",
+//                avatar.Name, avatar.UUID, Name, AgentId);
+
+            if (ent == null)
+                return;
+
+            ImprovedTerseObjectUpdatePacket objupdate =
+                (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate);
+            objupdate.Header.Zerocoded = true;
+
+            objupdate.RegionData.TimeDilation = Utils.FloatToUInt16(m_scene.TimeDilation, 0.0f, 1.0f);
+            objupdate.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[1];
+
+            if(ent is ScenePresence)
+            {
+                ScenePresence presence = ent as ScenePresence;
+                objupdate.RegionData.RegionHandle = presence.RegionHandle;
+                objupdate.ObjectData[0] = CreateImprovedTerseBlock(ent, false);
+            }
+            else if(ent is SceneObjectPart)
+            {
+                SceneObjectPart part = ent  as SceneObjectPart;
+                objupdate.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                objupdate.ObjectData[0] = CreateImprovedTerseBlock(ent, false);
+            }
+
+            OutPacket(objupdate, ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority);
+
+            // We need to record the avatar local id since the root prim of an attachment points to this.
+//            m_attachmentsSent.Add(avatar.LocalId);
+        }
+
+        public void SendCoarseLocationUpdate(List<UUID> users, List<Vector3> CoarseLocations)
+        {
+            // We don't need to update inactive clients.
+            if (!IsActive)
+                return;
+
+            CoarseLocationUpdatePacket loc = (CoarseLocationUpdatePacket)PacketPool.Instance.GetPacket(PacketType.CoarseLocationUpdate);
+            loc.Header.Reliable = false;
+
+            // Each packet can only hold around 60 avatar positions and the client clears the mini-map each time
+            // a CoarseLocationUpdate packet is received. Oh well.
+            int total = Math.Min(CoarseLocations.Count, 60);
+
+            CoarseLocationUpdatePacket.IndexBlock ib = new CoarseLocationUpdatePacket.IndexBlock();
+
+            loc.Location = new CoarseLocationUpdatePacket.LocationBlock[total];
+            loc.AgentData = new CoarseLocationUpdatePacket.AgentDataBlock[total];
+
+            int selfindex = -1;
+            for (int i = 0; i < total; i++)
+            {
+                CoarseLocationUpdatePacket.LocationBlock lb =
+                    new CoarseLocationUpdatePacket.LocationBlock();
+
+                lb.X = (byte)CoarseLocations[i].X;
+                lb.Y = (byte)CoarseLocations[i].Y;
+
+                lb.Z = CoarseLocations[i].Z > 1024 ? (byte)0 : (byte)(CoarseLocations[i].Z * 0.25f);
+                loc.Location[i] = lb;
+                loc.AgentData[i] = new CoarseLocationUpdatePacket.AgentDataBlock();
+                loc.AgentData[i].AgentID = users[i];
+                if (users[i] == AgentId)
+                    selfindex = i;
+            }
+
+            ib.You = (short)selfindex;
+            ib.Prey = -1;
+            loc.Index = ib;
+
+            OutPacket(loc, ThrottleOutPacketType.Task);
+        }
+
+        #endregion Avatar Packet/Data Sending Methods
+
+        #region Primitive Packet/Data Sending Methods
+
+        /// <summary>
+        /// Generate one of the object update packets based on PrimUpdateFlags
+        /// and broadcast the packet to clients
+        /// </summary>
+        public void SendEntityUpdate(ISceneEntity entity, PrimUpdateFlags updateFlags)
+        {
+/*
+            if (entity.UUID == m_agentId && !updateFlags.HasFlag(PrimUpdateFlags.FullUpdate))
+            {
+                ImprovedTerseObjectUpdatePacket packet
+                    = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate);
+
+                packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                packet.RegionData.TimeDilation = Utils.FloatToUInt16(1, 0.0f, 1.0f);
+                packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[1];
+                packet.ObjectData[0] = CreateImprovedTerseBlock(entity, false);
+                OutPacket(packet, ThrottleOutPacketType.Unknown, true);
+                return;
+            }
+*/
+            if (entity is SceneObjectPart)
+            {
+                SceneObjectPart p = (SceneObjectPart)entity;
+                SceneObjectGroup g = p.ParentGroup;
+                if (g.HasPrivateAttachmentPoint && g.OwnerID != AgentId)
+                    return; // Don't send updates for other people's HUDs
+                
+                if((updateFlags ^ PrimUpdateFlags.SendInTransit) == 0)
+                {
+                    List<uint> partIDs = (new List<uint> {p.LocalId});
+                    lock (m_entityProps.SyncRoot)
+                        m_entityProps.Remove(partIDs);
+                    lock (m_entityUpdates.SyncRoot)
+                        m_entityUpdates.Remove(partIDs);
+                    return;
+                }
+            }
+
+            //double priority = m_prioritizer.GetUpdatePriority(this, entity);
+            uint priority = m_prioritizer.GetUpdatePriority(this, entity);
+
+            lock (m_entityUpdates.SyncRoot)
+                m_entityUpdates.Enqueue(priority, new EntityUpdate(entity, updateFlags));
+        }
+
+        /// <summary>
+        /// Requeue an EntityUpdate when it was not acknowledged by the client.
+        /// We will update the priority and put it in the correct queue, merging update flags
+        /// with any other updates that may be queued for the same entity.
+        /// The original update time is used for the merged update.
+        /// </summary>
+        private void ResendPrimUpdate(EntityUpdate update)
+        {
+            // If the update exists in priority queue, it will be updated.
+            // If it does not exist then it will be added with the current (rather than its original) priority
+            uint priority = m_prioritizer.GetUpdatePriority(this, update.Entity);
+
+            lock (m_entityUpdates.SyncRoot)
+                m_entityUpdates.Enqueue(priority, update);
+        }
+
+        /// <summary>
+        /// Requeue a list of EntityUpdates when they were not acknowledged by the client.
+        /// We will update the priority and put it in the correct queue, merging update flags
+        /// with any other updates that may be queued for the same entity.
+        /// The original update time is used for the merged update.
+        /// </summary>
+        private void ResendPrimUpdates(List<EntityUpdate> updates, OutgoingPacket oPacket)
+        {
+            // m_log.WarnFormat("[CLIENT] resending prim updates {0}, packet sequence number {1}", updates[0].UpdateTime, oPacket.SequenceNumber);
+
+            // Remove the update packet from the list of packets waiting for acknowledgement
+            // because we are requeuing the list of updates. They will be resent in new packets
+            // with the most recent state and priority.
+            m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);
+
+            // Count this as a resent packet since we are going to requeue all of the updates contained in it
+            Interlocked.Increment(ref m_udpClient.PacketsResent);
+
+            // We're not going to worry about interlock yet since its not currently critical that this total count
+            // is 100% correct
+            m_udpServer.PacketsResentCount++;
+
+            foreach (EntityUpdate update in updates)
+                ResendPrimUpdate(update);
+        }
+
+        private List<ObjectUpdatePacket.ObjectDataBlock> objectUpdateBlocks = new List<ObjectUpdatePacket.ObjectDataBlock>();
+        private List<ObjectUpdateCompressedPacket.ObjectDataBlock> compressedUpdateBlocks = new List<ObjectUpdateCompressedPacket.ObjectDataBlock>();
+        private List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> terseUpdateBlocks = new List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
+        private List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> terseAgentUpdateBlocks = new List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
+
+        private void ProcessEntityUpdates(int maxUpdatesBytes)
+        {
+            OpenSim.Framework.Lazy<List<EntityUpdate>> objectUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();
+            OpenSim.Framework.Lazy<List<EntityUpdate>> compressedUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();
+            OpenSim.Framework.Lazy<List<EntityUpdate>> terseUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();
+            OpenSim.Framework.Lazy<List<EntityUpdate>> terseAgentUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();
+
+            // Check to see if this is a flush
+            if (maxUpdatesBytes <= 0)
+            {
+                maxUpdatesBytes = Int32.MaxValue;
+            }
+
+            EntityUpdate update;
+            Int32 timeinqueue; // this is just debugging code & can be dropped later
+
+            bool doCulling = m_scene.ObjectsCullingByDistance;
+            float cullingrange = 64.0f;
+            HashSet<SceneObjectGroup> GroupsNeedFullUpdate = new HashSet<SceneObjectGroup>();
+//            Vector3 mycamera = Vector3.Zero;
+            Vector3 mypos = Vector3.Zero;
+            ScenePresence mysp = (ScenePresence)SceneAgent;
+
+            bool orderedDequeue = m_scene.UpdatePrioritizationScheme  == UpdatePrioritizationSchemes.SimpleAngularDistance;
+            // we should have a presence
+            if(mysp == null)
+                return;
+
+            if(doCulling)
+            {
+                cullingrange = mysp.DrawDistance + m_scene.ReprioritizationDistance + 16f;
+//                mycamera = mysp.CameraPosition;
+                mypos = mysp.AbsolutePosition;
+            }
+
+            while (maxUpdatesBytes > 0)
+            {
+                lock (m_entityUpdates.SyncRoot)
+                {
+                    if(orderedDequeue)
+                    {
+                        if (!m_entityUpdates.TryOrderedDequeue(out update, out timeinqueue))
+                            break;
+                    }
+                    else
+                    {
+                        if (!m_entityUpdates.TryDequeue(out update, out timeinqueue))
+                            break;
+                    }
+                }
+
+                PrimUpdateFlags updateFlags = (PrimUpdateFlags)update.Flags;
+
+                if(updateFlags.HasFlag(PrimUpdateFlags.Kill))
+                {
+                    m_killRecord.Add(update.Entity.LocalId);
+                    maxUpdatesBytes -= 30;
+                    continue;
+                }
+
+                if (update.Entity is SceneObjectPart)
+                {
+                    SceneObjectPart part = (SceneObjectPart)update.Entity;
+                    SceneObjectGroup grp = part.ParentGroup;
+                    if (grp.inTransit && !update.Flags.HasFlag(PrimUpdateFlags.SendInTransit))
+                        continue;
+/* debug
+                    if (update.Flags.HasFlag(PrimUpdateFlags.SendInTransit))
+                    {
+
+
+                    }
+*/
+                    if (grp.IsDeleted)
+                    {
+                        // Don't send updates for objects that have been marked deleted.
+                        // Instead send another kill object, because the first one may have gotten
+                        // into a race condition
+                        if (part == grp.RootPart && !m_killRecord.Contains(grp.LocalId))
+                        {
+                            m_killRecord.Add(grp.LocalId);
+                            maxUpdatesBytes -= 30;
+                        }
+                        continue;
+                    }
+
+                    if (grp.IsAttachment)
+                    {   // Someone else's HUD, why are we getting these?
+                        if (grp.OwnerID != AgentId && grp.HasPrivateAttachmentPoint)
+                            continue;
+                        ScenePresence sp;
+                        // Owner is not in the sim, don't update it to
+                        // anyone
+                        if (!m_scene.TryGetScenePresence(part.OwnerID, out sp))
+                            continue;
+
+                        List<SceneObjectGroup> atts = sp.GetAttachments();
+                        bool found = false;
+                        foreach (SceneObjectGroup att in atts)
+                        {
+                            if (att == grp)
+                            {
+                                found = true;
+                                break;
+                            }
+                        }
+
+                        // It's an attachment of a valid avatar, but
+                        // doesn't seem to be attached, skip
+                        if (!found)
+                            continue;
+
+                        // On vehicle crossing, the attachments are received
+                        // while the avatar is still a child. Don't send
+                        // updates here because the LocalId has not yet
+                        // been updated and the viewer will derender the
+                        // attachments until the avatar becomes root.
+                        if (sp.IsChildAgent)
+                            continue;
+
+                    }
+
+                    if (grp.IsAttachment && m_disableFacelights)
+                    {
+                        if (grp.RootPart.Shape.State != (byte)AttachmentPoint.LeftHand &&
+                            grp.RootPart.Shape.State != (byte)AttachmentPoint.RightHand)
+                        {
+                            part.Shape.LightEntry = false;
+                        }
+                    }
+
+                    if(doCulling && !grp.IsAttachment)
+                    {
+                        if(GroupsNeedFullUpdate.Contains(grp))
+                            continue;
+
+                        bool inview = false;
+                        lock(GroupsInView)
+                            inview = GroupsInView.Contains(grp);
+
+                        if(!inview)
+                        {
+                            float bradius = grp.GetBoundsRadius();
+                            Vector3 partpos = grp.AbsolutePosition + grp.getBoundsCenter();
+//                            float dcam = (partpos - mycamera).LengthSquared();
+                            float dpos = (partpos - mypos).LengthSquared();
+//                            if(dcam < dpos)
+//                                dpos = dcam;
+                            dpos = (float)Math.Sqrt(dpos) - bradius;
+                            if(dpos > cullingrange)
+                                continue;
+
+                            GroupsNeedFullUpdate.Add(grp);
+                            continue;
+                        }
+                    }
+                }
+                else if (update.Entity is ScenePresence)
+                {
+                    ScenePresence presence = (ScenePresence)update.Entity;
+                    if (presence.IsDeleted)
+                        continue;
+                    // If ParentUUID is not UUID.Zero and ParentID is 0, this
+                    // avatar is in the process of crossing regions while
+                    // sat on an object. In this state, we don't want any
+                    // updates because they will visually orbit the avatar.
+                    // Update will be forced once crossing is completed anyway.
+                    if (presence.ParentUUID != UUID.Zero && presence.ParentID == 0)
+                        continue;
+                }
+
+                #region UpdateFlags to packet type conversion
+
+                bool canUseCompressed = true;
+                bool canUseImproved = true;
+
+
+                // Compressed object updates only make sense for LL primitives
+                if (!(update.Entity is SceneObjectPart))
+                {
+                    canUseCompressed = false;
+                }
+
+                if (updateFlags.HasFlag(PrimUpdateFlags.FullUpdate))
+                {
+                    canUseCompressed = false;
+                    canUseImproved = false;
+                }
+                else
+                {
+                    if (updateFlags.HasFlag(PrimUpdateFlags.Velocity) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Acceleration) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.CollisionPlane) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Joint))
+                    {
+                        canUseCompressed = false;
+                    }
+
+                    if (updateFlags.HasFlag(PrimUpdateFlags.PrimFlags) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.ParentID) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Scale) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.PrimData) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Text) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.NameValue) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.ExtraData) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.TextureAnim) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Sound) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Particles) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Material) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.ClickAction) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.MediaURL) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Joint))
+                    {
+                        canUseImproved = false;
+                    }
+                }
+
+                #endregion UpdateFlags to packet type conversion
+
+                #region Block Construction
+
+                // TODO: Remove this once we can build compressed updates
+                canUseCompressed = false;
+
+                if (!canUseImproved && !canUseCompressed)
+                {
+                    ObjectUpdatePacket.ObjectDataBlock ablock;
+                    if (update.Entity is ScenePresence)
+                        ablock = CreateAvatarUpdateBlock((ScenePresence)update.Entity);
+                    else
+                        ablock = CreatePrimUpdateBlock((SceneObjectPart)update.Entity, mysp);
+                    objectUpdateBlocks.Add(ablock);
+                    objectUpdates.Value.Add(update);
+                    maxUpdatesBytes -= ablock.Length;
+
+                }
+                else if (!canUseImproved)
+                {
+                    ObjectUpdateCompressedPacket.ObjectDataBlock ablock =
+                            CreateCompressedUpdateBlock((SceneObjectPart)update.Entity, updateFlags);
+                    compressedUpdateBlocks.Add(ablock);
+                    compressedUpdates.Value.Add(update);
+                    maxUpdatesBytes -= ablock.Length;
+                }
+                else
+                {
+                    ImprovedTerseObjectUpdatePacket.ObjectDataBlock ablock;
+                    if (update.Entity is ScenePresence)
+                    {
+                        // ALL presence updates go into a special list
+                        ablock = CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures));
+                        terseAgentUpdateBlocks.Add(ablock);
+                        terseAgentUpdates.Value.Add(update);
+                    }
+                    else
+                    {
+                        // Everything else goes here
+                        ablock = CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures));
+                        terseUpdateBlocks.Add(ablock);
+                        terseUpdates.Value.Add(update);
+                    }
+                    maxUpdatesBytes -= ablock.Length;
+                }
+
+                #endregion Block Construction
+            }
+
+            #region Packet Sending
+
+            ushort timeDilation;
+
+            if(!IsActive)
+                return;
+
+            timeDilation = Utils.FloatToUInt16(m_scene.TimeDilation, 0.0f, 1.0f);
+
+            if (terseAgentUpdateBlocks.Count > 0)
+            {
+                ImprovedTerseObjectUpdatePacket packet
+                    = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate);
+                packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                packet.RegionData.TimeDilation = timeDilation;
+                packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[terseAgentUpdateBlocks.Count];
+
+                for (int i = 0; i < terseAgentUpdateBlocks.Count; i++)
+                    packet.ObjectData[i] = terseAgentUpdateBlocks[i];
+
+                terseAgentUpdateBlocks.Clear();
+
+                OutPacket(packet, ThrottleOutPacketType.Unknown, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseAgentUpdates.Value, oPacket); });
+            }
+
+            if (objectUpdateBlocks.Count > 0)
+            {
+                ObjectUpdatePacket packet = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);
+                packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                packet.RegionData.TimeDilation = timeDilation;
+                packet.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[objectUpdateBlocks.Count];
+
+                for (int i = 0; i < objectUpdateBlocks.Count; i++)
+                    packet.ObjectData[i] = objectUpdateBlocks[i];
+
+                objectUpdateBlocks.Clear();
+
+                OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(objectUpdates.Value, oPacket); });
+            }
+
+            if (compressedUpdateBlocks.Count > 0)
+            {
+                ObjectUpdateCompressedPacket packet = (ObjectUpdateCompressedPacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdateCompressed);
+                packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                packet.RegionData.TimeDilation = timeDilation;
+                packet.ObjectData = new ObjectUpdateCompressedPacket.ObjectDataBlock[compressedUpdateBlocks.Count];
+
+                for (int i = 0; i < compressedUpdateBlocks.Count; i++)
+                    packet.ObjectData[i] = compressedUpdateBlocks[i];
+
+                compressedUpdateBlocks.Clear();
+
+                OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(compressedUpdates.Value, oPacket); });
+            }
+
+            if (terseUpdateBlocks.Count > 0)
+            {
+                ImprovedTerseObjectUpdatePacket packet
+                    = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(
+                        PacketType.ImprovedTerseObjectUpdate);
+                packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                packet.RegionData.TimeDilation = timeDilation;
+                packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[terseUpdateBlocks.Count];
+
+                for (int i = 0; i < terseUpdateBlocks.Count; i++)
+                    packet.ObjectData[i] = terseUpdateBlocks[i];
+
+                terseUpdateBlocks.Clear();
+
+                OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseUpdates.Value, oPacket); });
+            }
+
+            #endregion Packet Sending
+
+            #region Handle deleted objects
+            if (m_killRecord.Count > 0)
+            {
+                SendKillObject(m_killRecord);
+                m_killRecord.Clear();
+            }
+
+            if(GroupsNeedFullUpdate.Count > 0)
+            {
+                foreach(SceneObjectGroup grp in GroupsNeedFullUpdate)
+                {
+                    foreach(SceneObjectPart p in grp.Parts)
+                        SendEntityUpdate(p,PrimUpdateFlags.CancelKill);
+                    lock(GroupsInView)
+                        GroupsInView.Add(grp);
+                }
+            }
+            #endregion
+        }
+
+        // hack.. dont use
+/*
+        public void SendPartFullUpdate(ISceneEntity ent, uint? parentID)
+        {
+            if (ent is SceneObjectPart)
+            {
+                SceneObjectPart part = (SceneObjectPart)ent;
+                ObjectUpdatePacket packet = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);
+                packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                packet.RegionData.TimeDilation = Utils.FloatToUInt16(m_scene.TimeDilation, 0.0f, 1.0f);
+                packet.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
+
+                ObjectUpdatePacket.ObjectDataBlock blk = CreatePrimUpdateBlock(part, mysp);
+                if (parentID.HasValue)
+                {
+                    blk.ParentID = parentID.Value;
+                }
+
+                packet.ObjectData[0] = blk;
+
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
+            }
+
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Sent {0} updates in ProcessEntityUpdates() for {1} {2} in {3}",
+//                updatesThisCall, Name, SceneAgent.IsChildAgent ? "child" : "root", Scene.Name);
+//
+        }
+*/
+        public void ReprioritizeUpdates()
+        {
+            lock (m_entityUpdates.SyncRoot)
+                m_entityUpdates.Reprioritize(UpdatePriorityHandler);
+            CheckGroupsInView();
+        }
+
+        private bool CheckGroupsInViewBusy = false;
+
+        public void CheckGroupsInView()
+        {
+            bool doCulling = m_scene.ObjectsCullingByDistance;
+            if(!doCulling)
+                return;
+
+            if(CheckGroupsInViewBusy)
+                return;
+
+            CheckGroupsInViewBusy = true;
+
+            float cullingrange = 64.0f;
+//                Vector3 mycamera = Vector3.Zero;
+            Vector3 mypos = Vector3.Zero;
+            ScenePresence mysp = (ScenePresence)SceneAgent;
+            if(mysp != null && !mysp.IsDeleted)
+            {
+                cullingrange  = mysp.DrawDistance + m_scene.ReprioritizationDistance + 16f;
+//                    mycamera = mysp.CameraPosition;
+                mypos = mysp.AbsolutePosition;
+            }
+            else
+            {
+                CheckGroupsInViewBusy= false;
+                return;
+            }
+
+            HashSet<SceneObjectGroup> NewGroupsInView = new HashSet<SceneObjectGroup>();
+            HashSet<SceneObjectGroup> GroupsNeedFullUpdate = new HashSet<SceneObjectGroup>();
+            List<SceneObjectGroup> kills = new List<SceneObjectGroup>();
+
+            EntityBase[] entities = m_scene.Entities.GetEntities();
+            foreach (EntityBase e in entities)
+            {
+                if(!IsActive)
+                    return;
+
+                if (e != null && e is SceneObjectGroup)
+                {
+                    SceneObjectGroup grp = (SceneObjectGroup)e;
+                    if(grp.IsDeleted || grp.IsAttachment)
+                        continue;
+
+                    float bradius = grp.GetBoundsRadius();
+                    Vector3 grppos = grp.AbsolutePosition + grp.getBoundsCenter();
+//                        float dcam = (grppos - mycamera).LengthSquared();
+                    float dpos = (grppos - mypos).LengthSquared();
+//                        if(dcam < dpos)
+//                            dpos = dcam;
+
+                    dpos = (float)Math.Sqrt(dpos) - bradius;
+
+                    bool inview;
+                    lock(GroupsInView)
+                        inview = GroupsInView.Contains(grp);
+
+                    if(dpos > cullingrange)
+                    {
+                        if(inview)
+                            kills.Add(grp);
+                    }
+                    else
+                    {
+                        if(!inview)
+                            GroupsNeedFullUpdate.Add(grp);
+                        NewGroupsInView.Add(grp);
+                    }
+                }
+            }
+
+            lock(GroupsInView)
+                GroupsInView = NewGroupsInView;
+
+            if (kills.Count > 0)
+            {
+                List<uint> partIDs = new List<uint>();
+                foreach(SceneObjectGroup grp in kills)
+                {
+                    SendEntityUpdate(grp.RootPart,PrimUpdateFlags.Kill);
+                    foreach(SceneObjectPart p in grp.Parts)
+                    {
+                        if(p != grp.RootPart)
+                            partIDs.Add(p.LocalId);
+                    }
+                }
+                kills.Clear();
+                if(partIDs.Count > 0)
+                {
+                    lock (m_entityProps.SyncRoot)
+                        m_entityProps.Remove(partIDs);
+                    lock (m_entityUpdates.SyncRoot)
+                        m_entityUpdates.Remove(partIDs);
+                }
+            }
+
+            if(GroupsNeedFullUpdate.Count > 0)
+            {
+                foreach(SceneObjectGroup grp in GroupsNeedFullUpdate)
+                {
+                    foreach(SceneObjectPart p in grp.Parts)
+                        SendEntityUpdate(p,PrimUpdateFlags.CancelKill);
+                }
+            }
+
+            CheckGroupsInViewBusy = false;
+        }
+
+        private bool UpdatePriorityHandler(ref uint priority, ISceneEntity entity)
+        {
+            if (entity != null)
+            {
+                priority = m_prioritizer.GetUpdatePriority(this, entity);
+                return true;
+            }
+
+            return false;
+        }
+
+        public void FlushPrimUpdates()
+        {
+            m_log.WarnFormat("[CLIENT]: Flushing prim updates to " + m_firstName + " " + m_lastName);
+
+            while (m_entityUpdates.Count > 0)
+                ProcessEntityUpdates(-1);
+        }
+
+        #endregion Primitive Packet/Data Sending Methods
+
+        // These are used to implement an adaptive backoff in the number
+        // of updates converted to packets. Since we don't want packets
+        // to sit in the queue with old data, only convert enough updates
+        // to packets that can be sent in 200ms.
+//        private Int32 m_LastQueueFill = 0;
+//        private Int32 m_maxUpdates = 0;
+
+        void HandleQueueEmpty(ThrottleOutPacketTypeFlags categories)
+        {
+            if(m_scene == null)
+                return;
+
+            if ((categories & ThrottleOutPacketTypeFlags.Task) != 0)
+            {
+                int maxUpdateBytes = m_udpClient.GetCatBytesCanSend(ThrottleOutPacketType.Task, 30);
+
+                if (m_entityUpdates.Count > 0)
+                    ProcessEntityUpdates(maxUpdateBytes);
+
+                if (m_entityProps.Count > 0)
+                    ProcessEntityPropertyRequests(maxUpdateBytes);
+            }
+
+            if ((categories & ThrottleOutPacketTypeFlags.Texture) != 0)
+                ImageManager.ProcessImageQueue(m_udpServer.TextureSendLimit);
+    }
+
+        internal bool HandleHasUpdates(ThrottleOutPacketTypeFlags categories)
+        {
+            if ((categories & ThrottleOutPacketTypeFlags.Task) != 0)
+            {
+                if (m_entityUpdates.Count > 0)
+                    return true;
+                if (m_entityProps.Count > 0)
+                    return true;
+            }
+
+            if ((categories & ThrottleOutPacketTypeFlags.Texture) != 0)
+            {
+                if (ImageManager.HasUpdates())
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void SendAssetUploadCompleteMessage(sbyte AssetType, bool Success, UUID AssetFullID)
+        {
+            AssetUploadCompletePacket newPack = new AssetUploadCompletePacket();
+            newPack.AssetBlock.Type = AssetType;
+            newPack.AssetBlock.Success = Success;
+            newPack.AssetBlock.UUID = AssetFullID;
+            newPack.Header.Zerocoded = true;
+            OutPacket(newPack, ThrottleOutPacketType.Asset);
+        }
+
+        public void SendXferRequest(ulong XferID, short AssetType, UUID vFileID, byte FilePath, byte[] FileName)
+        {
+            RequestXferPacket newPack = new RequestXferPacket();
+            newPack.XferID.ID = XferID;
+            newPack.XferID.VFileType = AssetType;
+            newPack.XferID.VFileID = vFileID;
+            newPack.XferID.FilePath = FilePath;
+            newPack.XferID.Filename = FileName;
+            newPack.Header.Zerocoded = true;
+            OutPacket(newPack, ThrottleOutPacketType.Asset);
+        }
+
+        public void SendConfirmXfer(ulong xferID, uint PacketID)
+        {
+            ConfirmXferPacketPacket newPack = new ConfirmXferPacketPacket();
+            newPack.XferID.ID = xferID;
+            newPack.XferID.Packet = PacketID;
+            newPack.Header.Zerocoded = true;
+            OutPacket(newPack, ThrottleOutPacketType.Asset);
+        }
+
+        public void SendInitiateDownload(string simFileName, string clientFileName)
+        {
+            InitiateDownloadPacket newPack = new InitiateDownloadPacket();
+            newPack.AgentData.AgentID = AgentId;
+            newPack.FileData.SimFilename = Utils.StringToBytes(simFileName);
+            newPack.FileData.ViewerFilename = Utils.StringToBytes(clientFileName);
+            OutPacket(newPack, ThrottleOutPacketType.Asset);
+        }
+
+        public void SendImageFirstPart(
+            ushort numParts, UUID ImageUUID, uint ImageSize, byte[] ImageData, byte imageCodec)
+        {
+            ImageDataPacket im = new ImageDataPacket();
+            im.Header.Reliable = false;
+            im.ImageID.Packets = numParts;
+            im.ImageID.ID = ImageUUID;
+
+            if (ImageSize > 0)
+                im.ImageID.Size = ImageSize;
+
+            im.ImageData.Data = ImageData;
+            im.ImageID.Codec = imageCodec;
+            im.Header.Zerocoded = true;
+            OutPacket(im, ThrottleOutPacketType.Texture);
+        }
+
+        public void SendImageNextPart(ushort partNumber, UUID imageUuid, byte[] imageData)
+        {
+            ImagePacketPacket im = new ImagePacketPacket();
+            im.Header.Reliable = false;
+            im.ImageID.Packet = partNumber;
+            im.ImageID.ID = imageUuid;
+            im.ImageData.Data = imageData;
+
+            OutPacket(im, ThrottleOutPacketType.Texture);
+        }
+
+        public void SendImageNotFound(UUID imageid)
+        {
+            ImageNotInDatabasePacket notFoundPacket
+            = (ImageNotInDatabasePacket)PacketPool.Instance.GetPacket(PacketType.ImageNotInDatabase);
+
+            notFoundPacket.ImageID.ID = imageid;
+
+            OutPacket(notFoundPacket, ThrottleOutPacketType.Texture);
+        }
+
+        public void SendShutdownConnectionNotice()
+        {
+            OutPacket(PacketPool.Instance.GetPacket(PacketType.DisableSimulator), ThrottleOutPacketType.Unknown);
+        }
+
+        public void SendSimStats(SimStats stats)
+        {
+            SimStatsPacket pack = new SimStatsPacket();
+            pack.Region = new SimStatsPacket.RegionBlock();
+            pack.Region.RegionX = stats.RegionX;
+            pack.Region.RegionY = stats.RegionY;
+            pack.Region.RegionFlags = stats.RegionFlags;
+            pack.Region.ObjectCapacity = stats.ObjectCapacity;
+            //pack.Region = //stats.RegionBlock;
+            pack.Stat = stats.StatsBlock;
+
+            pack.Header.Reliable = false;
+            pack.RegionInfo = new SimStatsPacket.RegionInfoBlock[0];
+            OutPacket(pack, ThrottleOutPacketType.Task);
+        }
+
+        private class ObjectPropertyUpdate : EntityUpdate
+        {
+            internal bool SendFamilyProps;
+            internal bool SendObjectProps;
+
+            public ObjectPropertyUpdate(ISceneEntity entity, uint flags, bool sendfam, bool sendobj)
+                : base(entity,(PrimUpdateFlags)flags)
+            {
+                SendFamilyProps = sendfam;
+                SendObjectProps = sendobj;
+            }
+            public void Update(ObjectPropertyUpdate update)
+            {
+                SendFamilyProps = SendFamilyProps || update.SendFamilyProps;
+                SendObjectProps = SendObjectProps || update.SendObjectProps;
+                // other properties may need to be updated by base class
+                base.Update(update);
+            }
+        }
+
+        public void SendObjectPropertiesFamilyData(ISceneEntity entity, uint requestFlags)
+        {
+            uint priority = 0;  // time based ordering only
+            lock (m_entityProps.SyncRoot)
+                m_entityProps.Enqueue(priority, new ObjectPropertyUpdate(entity,requestFlags,true,false));
+        }
+
+        private void ResendPropertyUpdate(ObjectPropertyUpdate update)
+        {
+            uint priority = 0;
+            lock (m_entityProps.SyncRoot)
+                m_entityProps.Enqueue(priority, update);
+        }
+
+        private void ResendPropertyUpdates(List<ObjectPropertyUpdate> updates, OutgoingPacket oPacket)
+        {
+            // m_log.WarnFormat("[CLIENT] resending object property {0}",updates[0].UpdateTime);
+
+            // Remove the update packet from the list of packets waiting for acknowledgement
+            // because we are requeuing the list of updates. They will be resent in new packets
+            // with the most recent state.
+            m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);
+
+            // Count this as a resent packet since we are going to requeue all of the updates contained in it
+            Interlocked.Increment(ref m_udpClient.PacketsResent);
+
+            // We're not going to worry about interlock yet since its not currently critical that this total count
+            // is 100% correct
+            m_udpServer.PacketsResentCount++;
+
+            foreach (ObjectPropertyUpdate update in updates)
+                ResendPropertyUpdate(update);
+        }
+
+        public void SendObjectPropertiesReply(ISceneEntity entity)
+        {
+            uint priority = 0;  // time based ordering only
+            lock (m_entityProps.SyncRoot)
+                m_entityProps.Enqueue(priority, new ObjectPropertyUpdate(entity,0,false,true));
+        }
+
+       List<ObjectPropertiesFamilyPacket.ObjectDataBlock> objectFamilyBlocks = new
+                List<ObjectPropertiesFamilyPacket.ObjectDataBlock>();
+       List<ObjectPropertiesPacket.ObjectDataBlock> objectPropertiesBlocks =
+                new List<ObjectPropertiesPacket.ObjectDataBlock>();
+       List<SceneObjectPart> needPhysics = new List<SceneObjectPart>();
+
+        private void ProcessEntityPropertyRequests(int maxUpdateBytes)
+        {
+//            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> familyUpdates =
+//                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
+
+//            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> propertyUpdates =
+//                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
+
+            bool orderedDequeue = m_scene.UpdatePrioritizationScheme  == UpdatePrioritizationSchemes.SimpleAngularDistance;
+
+            EntityUpdate iupdate;
+            Int32 timeinqueue; // this is just debugging code & can be dropped later
+
+            while (maxUpdateBytes > 0)
+            {
+                lock (m_entityProps.SyncRoot)
+                {
+                    if(orderedDequeue)
+                    {
+                        if (!m_entityProps.TryOrderedDequeue(out iupdate, out timeinqueue))
+                            break;
+                    }
+                    else
+                    {
+                        if (!m_entityProps.TryDequeue(out iupdate, out timeinqueue))
+                            break;
+                    }
+                }
+
+                ObjectPropertyUpdate update = (ObjectPropertyUpdate)iupdate;
+                if (update.SendFamilyProps)
+                {
+                    if (update.Entity is SceneObjectPart)
+                    {
+                        SceneObjectPart sop = (SceneObjectPart)update.Entity;
+                        ObjectPropertiesFamilyPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesFamilyBlock(sop,update.Flags);
+                        objectFamilyBlocks.Add(objPropDB);
+//                        familyUpdates.Value.Add(update);
+                        maxUpdateBytes -= objPropDB.Length;
+                    }
+                }
+
+                if (update.SendObjectProps)
+                {
+                    if (update.Entity is SceneObjectPart)
+                    {
+                        SceneObjectPart sop = (SceneObjectPart)update.Entity;
+                        needPhysics.Add(sop);
+                        ObjectPropertiesPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesBlock(sop);
+                        objectPropertiesBlocks.Add(objPropDB);
+//                        propertyUpdates.Value.Add(update);
+                        maxUpdateBytes -= objPropDB.Length;
+                    }
+                }
+            }
+
+            if (objectPropertiesBlocks.Count > 0)
+            {
+                ObjectPropertiesPacket packet = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
+                packet.ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[objectPropertiesBlocks.Count];
+                for (int i = 0; i < objectPropertiesBlocks.Count; i++)
+                    packet.ObjectData[i] = objectPropertiesBlocks[i];
+
+
+                objectPropertiesBlocks.Clear();
+                packet.Header.Zerocoded = true;
+
+                // Pass in the delegate so that if this packet needs to be resent, we send the current properties
+                // of the object rather than the properties when the packet was created
+                // HACK : Remove intelligent resending until it's fixed in core
+                //OutPacket(packet, ThrottleOutPacketType.Task, true,
+                //          delegate(OutgoingPacket oPacket)
+                //          {
+                //              ResendPropertyUpdates(propertyUpdates.Value, oPacket);
+                //          });
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
+
+                // pbcnt += blocks.Count;
+                // ppcnt++;
+            }
+
+            // Int32 fpcnt = 0;
+            // Int32 fbcnt = 0;
+
+            if (objectFamilyBlocks.Count > 0)
+            {
+                // one packet per object block... uggh...
+                for (int i = 0; i < objectFamilyBlocks.Count; i++)
+                {
+                    ObjectPropertiesFamilyPacket packet =
+                        (ObjectPropertiesFamilyPacket)PacketPool.Instance.GetPacket(PacketType.ObjectPropertiesFamily);
+
+                    packet.ObjectData = objectFamilyBlocks[i];
+                    packet.Header.Zerocoded = true;
+
+                    // Pass in the delegate so that if this packet needs to be resent, we send the current properties
+                    // of the object rather than the properties when the packet was created
+//                    List<ObjectPropertyUpdate> updates = new List<ObjectPropertyUpdate>();
+//                    updates.Add(familyUpdates.Value[i]);
+                    // HACK : Remove intelligent resending until it's fixed in core
+                    //OutPacket(packet, ThrottleOutPacketType.Task, true,
+                    //          delegate(OutgoingPacket oPacket)
+                    //          {
+                    //              ResendPropertyUpdates(updates, oPacket);
+                    //          });
+                    OutPacket(packet, ThrottleOutPacketType.Task, true);
+
+                    // fpcnt++;
+                    // fbcnt++;
+                }
+                objectFamilyBlocks.Clear();
+            }
+
+            if(needPhysics.Count > 0)
+            {
+                IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
+                if(eq != null)
+                {
+                    OSDArray array = new OSDArray();
+                    foreach(SceneObjectPart sop in needPhysics)
+                    {
+                        OSDMap physinfo = new OSDMap(6);
+                        physinfo["LocalID"] = sop.LocalId;
+                        physinfo["Density"] = sop.Density;
+                        physinfo["Friction"] = sop.Friction;
+                        physinfo["GravityMultiplier"] = sop.GravityModifier;
+                        physinfo["Restitution"] = sop.Restitution;
+                        physinfo["PhysicsShapeType"] = (int)sop.PhysicsShapeType;
+                        array.Add(physinfo);
+                    }
+
+                    OSDMap llsdBody = new OSDMap(1);
+                    llsdBody.Add("ObjectData", array);
+
+                    eq.Enqueue(BuildEvent("ObjectPhysicsProperties", llsdBody),AgentId);
+                 }
+                 needPhysics.Clear();
+            }
+
+            // m_log.WarnFormat("[PACKETCOUNTS] queued {0} property packets with {1} blocks",ppcnt,pbcnt);
+            // m_log.WarnFormat("[PACKETCOUNTS] queued {0} family property packets with {1} blocks",fpcnt,fbcnt);
+        }
+
+        private ObjectPropertiesFamilyPacket.ObjectDataBlock CreateObjectPropertiesFamilyBlock(SceneObjectPart sop, PrimUpdateFlags requestFlags)
+        {
+            ObjectPropertiesFamilyPacket.ObjectDataBlock block = new ObjectPropertiesFamilyPacket.ObjectDataBlock();
+
+            block.RequestFlags = (uint)requestFlags;
+            block.ObjectID = sop.UUID;
+            if (sop.OwnerID == sop.GroupID)
+                block.OwnerID = UUID.Zero;
+            else
+                block.OwnerID = sop.OwnerID;
+            block.GroupID = sop.GroupID;
+            block.BaseMask = sop.BaseMask;
+            block.OwnerMask = sop.OwnerMask;
+            block.GroupMask = sop.GroupMask;
+            block.EveryoneMask = sop.EveryoneMask;
+            block.NextOwnerMask = sop.NextOwnerMask;
+
+            // TODO: More properties are needed in SceneObjectPart!
+            block.OwnershipCost = sop.OwnershipCost;
+            block.SaleType = sop.ObjectSaleType;
+            block.SalePrice = sop.SalePrice;
+            block.Category = sop.Category;
+            block.LastOwnerID = sop.LastOwnerID;
+            block.Name = Util.StringToBytes256(sop.Name);
+            block.Description = Util.StringToBytes256(sop.Description);
+
+            return block;
+        }
+
+        private ObjectPropertiesPacket.ObjectDataBlock CreateObjectPropertiesBlock(SceneObjectPart sop)
+        {
+            //ObjectPropertiesPacket proper = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
+            // TODO: don't create new blocks if recycling an old packet
+
+            ObjectPropertiesPacket.ObjectDataBlock block =
+                    new ObjectPropertiesPacket.ObjectDataBlock();
+
+            block.ObjectID = sop.UUID;
+            block.Name = Util.StringToBytes256(sop.Name);
+            block.Description = Util.StringToBytes256(sop.Description);
+
+            block.CreationDate = (ulong)sop.CreationDate * 1000000; // viewer wants date in microseconds
+            block.CreatorID = sop.CreatorID;
+            block.GroupID = sop.GroupID;
+            block.LastOwnerID = sop.LastOwnerID;
+            if (sop.OwnerID == sop.GroupID)
+                block.OwnerID = UUID.Zero;
+            else
+                block.OwnerID = sop.OwnerID;
+
+            block.ItemID = sop.FromUserInventoryItemID;
+            block.FolderID = UUID.Zero; // sog.FromFolderID ??
+            block.FromTaskID = UUID.Zero; // ???
+            block.InventorySerial = (short)sop.InventorySerial;
+
+            SceneObjectPart root = sop.ParentGroup.RootPart;
+
+            block.TouchName = Util.StringToBytes256(root.TouchName);
+
+            // SL 3.3.4, at least, appears to read this information as a concatenated byte[] stream of UUIDs but
+            // it's not yet clear whether this is actually used.  If this is done in the future then a pre-cached
+            // copy is really needed since it's less efficient to be constantly recreating this byte array.
+//            using (MemoryStream memStream = new MemoryStream())
+//            {
+//                using (BinaryWriter binWriter = new BinaryWriter(memStream))
+//                {
+//                    for (int i = 0; i < sop.GetNumberOfSides(); i++)
+//                    {
+//                        Primitive.TextureEntryFace teFace = sop.Shape.Textures.FaceTextures[i];
+//
+//                        UUID textureID;
+//
+//                        if (teFace != null)
+//                            textureID = teFace.TextureID;
+//                        else
+//                            textureID = sop.Shape.Textures.DefaultTexture.TextureID;
+//
+//                        binWriter.Write(textureID.GetBytes());
+//                    }
+//
+//                    block.TextureID = memStream.ToArray();
+//                }
+//            }
+
+            block.TextureID = new byte[0]; // TextureID ???
+            block.SitName = Util.StringToBytes256(root.SitName);
+            block.OwnerMask = root.OwnerMask;
+            block.NextOwnerMask = root.NextOwnerMask;
+            block.GroupMask = root.GroupMask;
+            block.EveryoneMask = root.EveryoneMask;
+            block.BaseMask = root.BaseMask;
+            block.SaleType = root.ObjectSaleType;
+            block.SalePrice = root.SalePrice;
+
+            return block;
+        }
+
+        #region Estate Data Sending Methods
+
+        private static bool convertParamStringToBool(byte[] field)
+        {
+            string s = Utils.BytesToString(field);
+            if (s == "1" || s.ToLower() == "y" || s.ToLower() == "yes" || s.ToLower() == "t" || s.ToLower() == "true")
+            {
+                return true;
+            }
+            return false;
+        }
+
+        public void SendEstateList(UUID invoice, int code, UUID[] Data, uint estateID)
+        {
+            int TotalnumberIDs = Data.Length;
+            int numberIDs;
+            int IDIndex = 0;
+
+            do
+            {
+                if(TotalnumberIDs > 63)
+                    numberIDs = 63;
+                else
+                    numberIDs = TotalnumberIDs;
+
+                TotalnumberIDs -= numberIDs;
+
+                EstateOwnerMessagePacket packet = new EstateOwnerMessagePacket();
+                packet.AgentData.TransactionID = UUID.Random();
+                packet.AgentData.AgentID = AgentId;
+                packet.AgentData.SessionID = SessionId;
+                packet.MethodData.Invoice = invoice;
+                packet.MethodData.Method = Utils.StringToBytes("setaccess");
+
+                EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[6 + numberIDs];
+
+                for (int i = 0; i < (6 + numberIDs); i++)
+                {
+                    returnblock[i] = new EstateOwnerMessagePacket.ParamListBlock();
+                }
+
+                returnblock[0].Parameter = Utils.StringToBytes(estateID.ToString());
+                returnblock[1].Parameter = Utils.StringToBytes(code.ToString());
+
+                if((code & 1) != 0) // allowagents
+                    returnblock[2].Parameter = Utils.StringToBytes(numberIDs.ToString());
+                else
+                    returnblock[2].Parameter = Utils.StringToBytes("0");
+
+                if((code & 2) != 0) // groups
+                    returnblock[3].Parameter = Utils.StringToBytes(numberIDs.ToString());
+                else
+                    returnblock[3].Parameter = Utils.StringToBytes("0");
+
+                if((code & 4) != 0) // bans
+                    returnblock[4].Parameter = Utils.StringToBytes(numberIDs.ToString());
+                else
+                    returnblock[4].Parameter = Utils.StringToBytes("0");
+
+                if((code & 8) != 0) // managers
+                    returnblock[5].Parameter = Utils.StringToBytes(numberIDs.ToString());
+                else
+                    returnblock[5].Parameter = Utils.StringToBytes("0");
+
+                int j = 6;
+
+                for (int i = 0; i < numberIDs; i++)
+                {
+                    returnblock[j].Parameter = Data[IDIndex].GetBytes();
+                    j++;
+                    IDIndex++;
+                }
+                packet.ParamList = returnblock;
+                packet.Header.Reliable = true;
+                OutPacket(packet, ThrottleOutPacketType.Task);
+            } while (TotalnumberIDs > 0);
+        }
+
+        public void SendBannedUserList(UUID invoice, EstateBan[] bl, uint estateID)
+        {
+            List<UUID> BannedUsers = new List<UUID>();
+            for (int i = 0; i < bl.Length; i++)
+            {
+                if (bl[i] == null)
+                    continue;
+                if (bl[i].BannedUserID == UUID.Zero)
+                    continue;
+                BannedUsers.Add(bl[i].BannedUserID);
+            }
+            SendEstateList(invoice, 4, BannedUsers.ToArray(), estateID);
+        }
+
+        public void SendRegionInfoToEstateMenu(RegionInfoForEstateMenuArgs args)
+        {
+            RegionInfoPacket rinfopack = new RegionInfoPacket();
+            RegionInfoPacket.RegionInfoBlock rinfoblk = new RegionInfoPacket.RegionInfoBlock();
+            rinfopack.AgentData.AgentID = AgentId;
+            rinfopack.AgentData.SessionID = SessionId;
+            rinfoblk.BillableFactor = args.billableFactor;
+            rinfoblk.EstateID = args.estateID;
+            rinfoblk.MaxAgents = args.maxAgents;
+            rinfoblk.ObjectBonusFactor = args.objectBonusFactor;
+            rinfoblk.ParentEstateID = args.parentEstateID;
+            rinfoblk.PricePerMeter = args.pricePerMeter;
+            rinfoblk.RedirectGridX = args.redirectGridX;
+            rinfoblk.RedirectGridY = args.redirectGridY;
+            rinfoblk.RegionFlags = args.regionFlags;
+            rinfoblk.SimAccess = args.simAccess;
+            rinfoblk.SunHour = args.sunHour;
+            rinfoblk.TerrainLowerLimit = args.terrainLowerLimit;
+            rinfoblk.TerrainRaiseLimit = args.terrainRaiseLimit;
+            rinfoblk.UseEstateSun = args.useEstateSun;
+            rinfoblk.WaterHeight = args.waterHeight;
+            rinfoblk.SimName = Utils.StringToBytes(args.simName);
+
+            rinfopack.RegionInfo2 = new RegionInfoPacket.RegionInfo2Block();
+            rinfopack.RegionInfo2.HardMaxAgents = uint.MaxValue;
+            rinfopack.RegionInfo2.HardMaxObjects = uint.MaxValue;
+            rinfopack.RegionInfo2.MaxAgents32 = uint.MaxValue;
+            rinfopack.RegionInfo2.ProductName = Util.StringToBytes256(args.regionType);
+            rinfopack.RegionInfo2.ProductSKU = Utils.EmptyBytes;
+
+            rinfopack.HasVariableBlocks = true;
+            rinfopack.RegionInfo = rinfoblk;
+            rinfopack.AgentData = new RegionInfoPacket.AgentDataBlock();
+            rinfopack.AgentData.AgentID = AgentId;
+            rinfopack.AgentData.SessionID = SessionId;
+            rinfopack.RegionInfo3 = new RegionInfoPacket.RegionInfo3Block[0];
+
+            OutPacket(rinfopack, ThrottleOutPacketType.Task);
+        }
+
+        public void SendEstateCovenantInformation(UUID covenant)
+        {
+//            m_log.DebugFormat("[LLCLIENTVIEW]: Sending estate covenant asset id of {0} to {1}", covenant, Name);
+
+            EstateCovenantReplyPacket einfopack = new EstateCovenantReplyPacket();
+            EstateCovenantReplyPacket.DataBlock edata = new EstateCovenantReplyPacket.DataBlock();
+            edata.CovenantID = covenant;
+            edata.CovenantTimestamp = (uint) m_scene.RegionInfo.RegionSettings.CovenantChangedDateTime;
+            edata.EstateOwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
+            edata.EstateName = Utils.StringToBytes(m_scene.RegionInfo.EstateSettings.EstateName);
+            einfopack.Data = edata;
+            OutPacket(einfopack, ThrottleOutPacketType.Task);
+        }
+
+        public void SendDetailedEstateData(
+            UUID invoice, string estateName, uint estateID, uint parentEstate, uint estateFlags, uint sunPosition,
+            UUID covenant, uint covenantChanged, string abuseEmail, UUID estateOwner)
+        {
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Sending detailed estate data to {0} with covenant asset id {1}", Name, covenant);
+
+            EstateOwnerMessagePacket packet = new EstateOwnerMessagePacket();
+            packet.MethodData.Invoice = invoice;
+            packet.AgentData.TransactionID = UUID.Random();
+            packet.MethodData.Method = Utils.StringToBytes("estateupdateinfo");
+            EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[10];
+
+            for (int i = 0; i < 10; i++)
+            {
+                returnblock[i] = new EstateOwnerMessagePacket.ParamListBlock();
+            }
+
+            //Sending Estate Settings
+            returnblock[0].Parameter = Utils.StringToBytes(estateName);
+            returnblock[1].Parameter = Utils.StringToBytes(estateOwner.ToString());
+            returnblock[2].Parameter = Utils.StringToBytes(estateID.ToString());
+
+            returnblock[3].Parameter = Utils.StringToBytes(estateFlags.ToString());
+            returnblock[4].Parameter = Utils.StringToBytes(sunPosition.ToString());
+            returnblock[5].Parameter = Utils.StringToBytes(parentEstate.ToString());
+            returnblock[6].Parameter = Utils.StringToBytes(covenant.ToString());
+            returnblock[7].Parameter = Utils.StringToBytes(covenantChanged.ToString());
+            returnblock[8].Parameter = Utils.StringToBytes("1"); // what is this?
+            returnblock[9].Parameter = Utils.StringToBytes(abuseEmail);
+
+            packet.ParamList = returnblock;
+            packet.Header.Reliable = false;
+            //m_log.Debug("[ESTATE]: SIM--->" + packet.ToString());
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendTelehubInfo(UUID ObjectID, string ObjectName, Vector3 ObjectPos, Quaternion ObjectRot, List<Vector3> SpawnPoint)
+        {
+            TelehubInfoPacket packet = (TelehubInfoPacket)PacketPool.Instance.GetPacket(PacketType.TelehubInfo);
+            packet.TelehubBlock.ObjectID = ObjectID;
+            packet.TelehubBlock.ObjectName = Utils.StringToBytes(ObjectName);
+            packet.TelehubBlock.TelehubPos = ObjectPos;
+            packet.TelehubBlock.TelehubRot = ObjectRot;
+
+            packet.SpawnPointBlock = new TelehubInfoPacket.SpawnPointBlockBlock[SpawnPoint.Count];
+            for (int n = 0; n < SpawnPoint.Count; n++)
+            {
+                packet.SpawnPointBlock[n] = new TelehubInfoPacket.SpawnPointBlockBlock{SpawnPointPos = SpawnPoint[n]};
+            }
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        #endregion
+
+        #region Land Data Sending Methods
+
+        public void SendLandParcelOverlay(byte[] data, int sequence_id)
+        {
+            ParcelOverlayPacket packet = (ParcelOverlayPacket)PacketPool.Instance.GetPacket(PacketType.ParcelOverlay);
+            packet.ParcelData.Data = data;
+            packet.ParcelData.SequenceID = sequence_id;
+            packet.Header.Zerocoded = true;
+//            OutPacket(packet, ThrottleOutPacketType.Task);
+            OutPacket(packet, ThrottleOutPacketType.Land);
+        }
+
+        public void SendLandProperties(
+             int sequence_id, bool snap_selection, int request_result, ILandObject lo,
+             float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
+        {
+//            m_log.DebugFormat("[LLCLIENTVIEW]: Sending land properties for {0} to {1}", lo.LandData.GlobalID, Name);
+
+            LandData landData = lo.LandData;
+
+            ParcelPropertiesMessage updateMessage = new ParcelPropertiesMessage();
+
+            updateMessage.AABBMax = landData.AABBMax;
+            updateMessage.AABBMin = landData.AABBMin;
+            updateMessage.Area = landData.Area;
+            updateMessage.AuctionID = landData.AuctionID;
+            updateMessage.AuthBuyerID = landData.AuthBuyerID;
+            updateMessage.Bitmap = landData.Bitmap;
+            updateMessage.Desc = landData.Description;
+            updateMessage.Category = landData.Category;
+            updateMessage.ClaimDate = Util.ToDateTime(landData.ClaimDate);
+            updateMessage.ClaimPrice = landData.ClaimPrice;
+            updateMessage.GroupID = landData.GroupID;
+            updateMessage.IsGroupOwned = landData.IsGroupOwned;
+            updateMessage.LandingType = (LandingType) landData.LandingType;
+            updateMessage.LocalID = landData.LocalID;
+
+            if (landData.Area > 0)
+            {
+                updateMessage.MaxPrims = parcelObjectCapacity;
+            }
+            else
+            {
+                updateMessage.MaxPrims = 0;
+            }
+
+            updateMessage.MediaAutoScale = Convert.ToBoolean(landData.MediaAutoScale);
+            updateMessage.MediaID = landData.MediaID;
+            updateMessage.MediaURL = landData.MediaURL;
+            updateMessage.MusicURL = landData.MusicURL;
+            updateMessage.Name = landData.Name;
+            updateMessage.OtherCleanTime = landData.OtherCleanTime;
+            updateMessage.OtherCount = 0; //TODO: Unimplemented
+            updateMessage.OwnerID = landData.OwnerID;
+            updateMessage.ParcelFlags = (ParcelFlags) landData.Flags;
+            updateMessage.ParcelPrimBonus = simObjectBonusFactor;
+            updateMessage.PassHours = landData.PassHours;
+            updateMessage.PassPrice = landData.PassPrice;
+            updateMessage.PublicCount = 0; //TODO: Unimplemented
+
+            updateMessage.RegionPushOverride = (regionFlags & (uint)RegionFlags.RestrictPushObject) > 0;
+            updateMessage.RegionDenyAnonymous = (regionFlags & (uint)RegionFlags.DenyAnonymous) > 0;
+
+            //updateMessage.RegionDenyIdentified = (regionFlags & (uint)RegionFlags.DenyIdentified) > 0;
+            //updateMessage.RegionDenyTransacted = (regionFlags & (uint)RegionFlags.DenyTransacted) > 0;
+
+            updateMessage.RentPrice = 0;
+            updateMessage.RequestResult = (ParcelResult) request_result;
+            updateMessage.SalePrice = landData.SalePrice;
+            updateMessage.SelfCount = 0; //TODO: Unimplemented
+            updateMessage.SequenceID = sequence_id;
+
+            if (landData.SimwideArea > 0)
+            {
+                updateMessage.SimWideMaxPrims = lo.GetSimulatorMaxPrimCount();
+            }
+            else
+            {
+                updateMessage.SimWideMaxPrims = 0;
+            }
+
+            updateMessage.SnapSelection = snap_selection;
+            updateMessage.SnapshotID    = landData.SnapshotID;
+            updateMessage.Status        = (ParcelStatus) landData.Status;
+            updateMessage.UserLocation  = landData.UserLocation;
+            updateMessage.UserLookAt    = landData.UserLookAt;
+
+            updateMessage.MediaType     = landData.MediaType;
+            updateMessage.MediaDesc     = landData.MediaDescription;
+            updateMessage.MediaWidth    = landData.MediaWidth;
+            updateMessage.MediaHeight   = landData.MediaHeight;
+            updateMessage.MediaLoop     = landData.MediaLoop;
+            updateMessage.ObscureMusic  = landData.ObscureMusic;
+            updateMessage.ObscureMedia  = landData.ObscureMedia;
+
+            updateMessage.SeeAVs        = landData.SeeAVs;
+            updateMessage.AnyAVSounds   = landData.AnyAVSounds;
+            updateMessage.GroupAVSounds = landData.GroupAVSounds;
+
+            IPrimCounts pc = lo.PrimCounts;
+            updateMessage.OwnerPrims        = pc.Owner;
+            updateMessage.GroupPrims        = pc.Group;
+            updateMessage.OtherPrims        = pc.Others;
+            updateMessage.SelectedPrims     = pc.Selected;
+            updateMessage.TotalPrims        = pc.Total;
+            updateMessage.SimWideTotalPrims = pc.Simulator;
+
+            //m_log.DebugFormat("[YYY]: SimWideMaxPrims={0} OwnerPrims={1} TotalPrims={2} SimWideTotalPrims={3} MaxPrims={4}",
+            //    updateMessage.SimWideMaxPrims, updateMessage.OwnerPrims, updateMessage.TotalPrims, updateMessage.SimWideTotalPrims, updateMessage.MaxPrims);
+            try
+            {
+                IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
+                if (eq != null)
+                {
+                    eq.ParcelProperties(updateMessage, this.AgentId);
+                }
+                else
+                {
+                    m_log.Warn("[LLCLIENTVIEW]: No EQ Interface when sending parcel data.");
+                }
+            }
+            catch (Exception ex)
+            {
+                m_log.Error("[LLCLIENTVIEW]: Unable to send parcel data via eventqueue - exception: " + ex.ToString());
+            }
+        }
+
+        public void SendLandAccessListData(List<LandAccessEntry> accessList, uint accessFlag, int localLandID)
+        {
+            ParcelAccessListReplyPacket replyPacket = (ParcelAccessListReplyPacket)PacketPool.Instance.GetPacket(PacketType.ParcelAccessListReply);
+            replyPacket.Data.AgentID = AgentId;
+            replyPacket.Data.Flags = accessFlag;
+            replyPacket.Data.LocalID = localLandID;
+            replyPacket.Data.SequenceID = 0;
+
+            List<ParcelAccessListReplyPacket.ListBlock> list = new List<ParcelAccessListReplyPacket.ListBlock>();
+            foreach (LandAccessEntry entry in accessList)
+            {
+                ParcelAccessListReplyPacket.ListBlock block = new ParcelAccessListReplyPacket.ListBlock();
+                block.Flags = accessFlag;
+                block.ID = entry.AgentID;
+                block.Time = entry.Expires;
+                list.Add(block);
+            }
+
+            replyPacket.List = list.ToArray();
+            replyPacket.Header.Zerocoded = true;
+            OutPacket(replyPacket, ThrottleOutPacketType.Task);
+        }
+
+        public void SendForceClientSelectObjects(List<uint> ObjectIDs)
+        {
+//            m_log.DebugFormat("[LLCLIENTVIEW] sending select with {0} objects", ObjectIDs.Count);
+
+            bool firstCall = true;
+            const int MAX_OBJECTS_PER_PACKET = 251;
+            ForceObjectSelectPacket pack = (ForceObjectSelectPacket)PacketPool.Instance.GetPacket(PacketType.ForceObjectSelect);
+            ForceObjectSelectPacket.DataBlock[] data;
+            while (ObjectIDs.Count > 0)
+            {
+                if (firstCall)
+                {
+                    pack._Header.ResetList = true;
+                    firstCall = false;
+                }
+                else
+                {
+                    pack._Header.ResetList = false;
+                }
+
+                if (ObjectIDs.Count > MAX_OBJECTS_PER_PACKET)
+                {
+                    data = new ForceObjectSelectPacket.DataBlock[MAX_OBJECTS_PER_PACKET];
+                }
+                else
+                {
+                    data = new ForceObjectSelectPacket.DataBlock[ObjectIDs.Count];
+                }
+
+                int i;
+                for (i = 0; i < MAX_OBJECTS_PER_PACKET && ObjectIDs.Count > 0; i++)
+                {
+                    data[i] = new ForceObjectSelectPacket.DataBlock();
+                    data[i].LocalID = Convert.ToUInt32(ObjectIDs[0]);
+                    ObjectIDs.RemoveAt(0);
+                }
+                pack.Data = data;
+                pack.Header.Zerocoded = true;
+                OutPacket(pack, ThrottleOutPacketType.Task);
+            }
+        }
+
+        public void SendCameraConstraint(Vector4 ConstraintPlane)
+        {
+            CameraConstraintPacket cpack = (CameraConstraintPacket)PacketPool.Instance.GetPacket(PacketType.CameraConstraint);
+            cpack.CameraCollidePlane = new CameraConstraintPacket.CameraCollidePlaneBlock();
+            cpack.CameraCollidePlane.Plane = ConstraintPlane;
+            //m_log.DebugFormat("[CLIENTVIEW]: Constraint {0}", ConstraintPlane);
+            OutPacket(cpack, ThrottleOutPacketType.Task);
+        }
+
+        public void SendLandObjectOwners(LandData land, List<UUID> groups, Dictionary<UUID, int> ownersAndCount)
+        {
+            int notifyCount = ownersAndCount.Count;
+            ParcelObjectOwnersReplyPacket pack = (ParcelObjectOwnersReplyPacket)PacketPool.Instance.GetPacket(PacketType.ParcelObjectOwnersReply);
+
+            if (notifyCount > 0)
+            {
+//                if (notifyCount > 32)
+//                {
+//                    m_log.InfoFormat(
+//                        "[LAND]: More than {0} avatars own prims on this parcel.  Only sending back details of first {0}"
+//                        + " - a developer might want to investigate whether this is a hard limit", 32);
+//
+//                    notifyCount = 32;
+//                }
+
+                ParcelObjectOwnersReplyPacket.DataBlock[] dataBlock
+                    = new ParcelObjectOwnersReplyPacket.DataBlock[notifyCount];
+
+                int num = 0;
+                foreach (UUID owner in ownersAndCount.Keys)
+                {
+                    dataBlock[num] = new ParcelObjectOwnersReplyPacket.DataBlock();
+                    dataBlock[num].Count = ownersAndCount[owner];
+
+                    if (land.GroupID == owner || groups.Contains(owner))
+                        dataBlock[num].IsGroupOwned = true;
+
+                    dataBlock[num].OnlineStatus = true; //TODO: fix me later
+                    dataBlock[num].OwnerID = owner;
+
+                    num++;
+
+                    if (num >= notifyCount)
+                    {
+                        break;
+                    }
+                }
+
+                pack.Data = dataBlock;
+            }
+            else
+            {
+                pack.Data = new ParcelObjectOwnersReplyPacket.DataBlock[0];
+            }
+            pack.Header.Zerocoded = true;
+            this.OutPacket(pack, ThrottleOutPacketType.Task);
+        }
+
+        #endregion
+
+        #region Helper Methods
+        private void ClampVectorForUint(ref Vector3 v, float max)
+        {
+            float a,b;
+
+            a = Math.Abs(v.X);
+            b = Math.Abs(v.Y);
+            if(b > a)
+                a = b;
+            b= Math.Abs(v.Z);
+            if(b > a)
+                a = b;
+
+            if (a > max)
+            {
+                a = max / a;
+                v.X *= a;
+                v.Y *= a;
+                v.Z *= a;
+            }
+        }
+
+        protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(ISceneEntity entity, bool sendTexture)
+        {
+            #region ScenePresence/SOP Handling
+
+            bool avatar = (entity is ScenePresence);
+            uint localID = entity.LocalId;
+            uint attachPoint;
+            Vector4 collisionPlane;
+            Vector3 position, velocity, acceleration, angularVelocity;
+            Quaternion rotation;
+            byte[] textureEntry;
+
+            if (avatar)
+            {
+                ScenePresence presence = (ScenePresence)entity;
+
+                position = presence.OffsetPosition;
+                velocity = presence.Velocity;
+                acceleration = Vector3.Zero;
+                rotation = presence.Rotation;
+                // tpvs can only see rotations around Z in some cases
+                if(!presence.Flying && !presence.IsSatOnObject)
+                {
+                    rotation.X = 0f;
+                    rotation.Y = 0f;
+                    rotation.Normalize();
+                }
+                angularVelocity = presence.AngularVelocity;
+
+//                m_log.DebugFormat(
+//                    "[LLCLIENTVIEW]: Sending terse update to {0} with position {1} in {2}", Name, presence.OffsetPosition, m_scene.Name);
+
+                attachPoint = presence.State;
+                collisionPlane = presence.CollisionPlane;
+
+                if (sendTexture)
+                {
+                    textureEntry = presence.Appearance.Texture.GetBytes();
+                }
+                else
+                    textureEntry = null;
+            }
+            else
+            {
+                SceneObjectPart part = (SceneObjectPart)entity;
+
+                attachPoint = part.ParentGroup.AttachmentPoint;
+                attachPoint = ((attachPoint % 16) * 16 + (attachPoint / 16));
+//                m_log.DebugFormat(
+//                    "[LLCLIENTVIEW]: Sending attachPoint {0} for {1} {2} to {3}",
+//                    attachPoint, part.Name, part.LocalId, Name);
+
+                collisionPlane = Vector4.Zero;
+                position = part.RelativePosition;
+                velocity = part.Velocity;
+                acceleration = part.Acceleration;
+                angularVelocity = part.AngularVelocity;
+                rotation = part.RotationOffset;
+
+                if (sendTexture)
+                    textureEntry = part.Shape.TextureEntry;
+                else
+                    textureEntry = null;
+            }
+
+            #endregion ScenePresence/SOP Handling
+
+            int pos = 0;
+            byte[] data = new byte[(avatar ? 60 : 44)];
+
+            // LocalID
+            Utils.UIntToBytes(localID, data, pos);
+            pos += 4;
+
+            // Avatar/CollisionPlane
+            data[pos++] = (byte) attachPoint;
+            if (avatar)
+            {
+                data[pos++] = 1;
+
+                if (collisionPlane == Vector4.Zero)
+                    collisionPlane = Vector4.UnitW;
+                //m_log.DebugFormat("CollisionPlane: {0}",collisionPlane);
+                collisionPlane.ToBytes(data, pos);
+                pos += 16;
+            }
+            else
+            {
+                ++pos;
+            }
+
+            // Position
+            position.ToBytes(data, pos);
+            pos += 12;
+
+            // Velocity
+            ClampVectorForUint(ref velocity, 128f);
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(velocity.X, -128.0f, 128.0f), data, pos); pos += 2;
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(velocity.Y, -128.0f, 128.0f), data, pos); pos += 2;
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(velocity.Z, -128.0f, 128.0f), data, pos); pos += 2;
+
+            // Acceleration
+            ClampVectorForUint(ref acceleration, 64f);
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(acceleration.X, -64.0f, 64.0f), data, pos); pos += 2;
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(acceleration.Y, -64.0f, 64.0f), data, pos); pos += 2;
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(acceleration.Z, -64.0f, 64.0f), data, pos); pos += 2;
+
+            // Rotation
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(rotation.X, -1.0f, 1.0f), data, pos); pos += 2;
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(rotation.Y, -1.0f, 1.0f), data, pos); pos += 2;
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(rotation.Z, -1.0f, 1.0f), data, pos); pos += 2;
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(rotation.W, -1.0f, 1.0f), data, pos); pos += 2;
+
+            // Angular Velocity
+            ClampVectorForUint(ref angularVelocity, 64f);
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(angularVelocity.X, -64.0f, 64.0f), data, pos); pos += 2;
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(angularVelocity.Y, -64.0f, 64.0f), data, pos); pos += 2;
+            Utils.UInt16ToBytes(Utils.FloatToUInt16(angularVelocity.Z, -64.0f, 64.0f), data, pos); pos += 2;
+
+            ImprovedTerseObjectUpdatePacket.ObjectDataBlock block
+                = PacketPool.Instance.GetDataBlock<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
+
+            block.Data = data;
+
+            if (textureEntry != null && textureEntry.Length > 0)
+            {
+                byte[] teBytesFinal = new byte[textureEntry.Length + 4];
+
+                // Texture Length
+                Utils.IntToBytes(textureEntry.Length, textureEntry, 0);
+                // Texture
+                Buffer.BlockCopy(textureEntry, 0, teBytesFinal, 4, textureEntry.Length);
+
+                block.TextureEntry = teBytesFinal;
+            }
+            else
+            {
+                block.TextureEntry = Utils.EmptyBytes;
+            }
+
+            return block;
+        }
+
+        protected ObjectUpdatePacket.ObjectDataBlock CreateAvatarUpdateBlock(ScenePresence data)
+        {
+            Vector3 offsetPosition = data.OffsetPosition;
+            Quaternion rotation = data.Rotation;
+            uint parentID = data.ParentID;
+
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Sending full update to {0} with pos {1}, vel {2} in {3}", Name, data.OffsetPosition, data.Velocity, m_scene.Name);
+
+            byte[] objectData = new byte[76];
+
+            Vector3 velocity = new Vector3(0, 0, 0);
+            Vector3 acceleration = new Vector3(0, 0, 0);
+            // tpvs can only see rotations around Z in some cases
+            if(!data.Flying && !data.IsSatOnObject)
+            {
+                rotation.X = 0f;
+                rotation.Y = 0f;
+            }
+            rotation.Normalize();
+
+            data.CollisionPlane.ToBytes(objectData, 0);
+            offsetPosition.ToBytes(objectData, 16);
+            velocity.ToBytes(objectData, 28);
+            acceleration.ToBytes(objectData, 40);
+            rotation.ToBytes(objectData, 52);
+            data.AngularVelocity.ToBytes(objectData, 64);
+
+            ObjectUpdatePacket.ObjectDataBlock update = new ObjectUpdatePacket.ObjectDataBlock();
+
+            update.Data = Utils.EmptyBytes;
+            update.ExtraParams = new byte[1];
+            update.FullID = data.UUID;
+            update.ID = data.LocalId;
+            update.Material = (byte)Material.Flesh;
+            update.MediaURL = Utils.EmptyBytes;
+            update.NameValue = Utils.StringToBytes("FirstName STRING RW SV " + data.Firstname + "\nLastName STRING RW SV " +
+                data.Lastname + "\nTitle STRING RW SV " + data.Grouptitle);
+            update.ObjectData = objectData;
+
+            SceneObjectPart parentPart = data.ParentPart;
+            if (parentPart != null)
+                update.ParentID = parentPart.ParentGroup.LocalId;
+            else
+                update.ParentID = 0;
+
+            update.PathCurve = 16;
+            update.PathScaleX = 100;
+            update.PathScaleY = 100;
+            update.PCode = (byte)PCode.Avatar;
+            update.ProfileCurve = 1;
+            update.PSBlock = Utils.EmptyBytes;
+            update.Scale = data.Appearance.AvatarSize;
+//            update.Scale.Z -= 0.2f;
+
+            update.Text = Utils.EmptyBytes;
+            update.TextColor = new byte[4];
+
+            // Don't send texture anim for avatars - this has no meaning for them.
+            update.TextureAnim = Utils.EmptyBytes;
+
+            // Don't send texture entry for avatars here - this is accomplished via the AvatarAppearance packet
+            update.TextureEntry = Utils.EmptyBytes;
+//            update.TextureEntry = (data.Appearance.Texture != null) ? data.Appearance.Texture.GetBytes() : Utils.EmptyBytes;
+
+/*  all this flags seem related to prims and not avatars. This allow for wrong viewer side move of a avatar in prim edition mode (anv mantis 854)
+            update.UpdateFlags = (uint)(
+                PrimFlags.Physics | PrimFlags.ObjectModify | PrimFlags.ObjectCopy | PrimFlags.ObjectAnyOwner |
+                PrimFlags.ObjectYouOwner | PrimFlags.ObjectMove | PrimFlags.InventoryEmpty | PrimFlags.ObjectTransfer |
+                PrimFlags.ObjectOwnerModify);
+*/
+            update.UpdateFlags = 0;
+
+            return update;
+        }
+
+//        protected ObjectUpdatePacket.ObjectDataBlock CreatePrimUpdateBlock(SceneObjectPart data, UUID recipientID)
+        protected ObjectUpdatePacket.ObjectDataBlock CreatePrimUpdateBlock(SceneObjectPart part, ScenePresence sp)
+        {
+            byte[] objectData = new byte[60];
+            part.RelativePosition.ToBytes(objectData, 0);
+            part.Velocity.ToBytes(objectData, 12);
+            part.Acceleration.ToBytes(objectData, 24);
+
+            Quaternion rotation = part.RotationOffset;
+            rotation.Normalize();
+            rotation.ToBytes(objectData, 36);
+            part.AngularVelocity.ToBytes(objectData, 48);
+
+            ObjectUpdatePacket.ObjectDataBlock update = new ObjectUpdatePacket.ObjectDataBlock();
+            update.ClickAction = (byte)part.ClickAction;
+            update.CRC = 0;
+            update.ExtraParams = part.Shape.ExtraParams ?? Utils.EmptyBytes;
+            update.FullID = part.UUID;
+            update.ID = part.LocalId;
+            //update.JointAxisOrAnchor = Vector3.Zero; // These are deprecated
+            //update.JointPivot = Vector3.Zero;
+            //update.JointType = 0;
+            update.Material = part.Material;
+/*
+            if (data.ParentGroup.IsAttachment)
+            {
+                update.NameValue
+                    = Util.StringToBytes256(
+                        string.Format("AttachItemID STRING RW SV {0}", data.ParentGroup.FromItemID));
+
+                update.State = (byte)((data.ParentGroup.AttachmentPoint % 16) * 16 + (data.ParentGroup.AttachmentPoint / 16));
+
+//                m_log.DebugFormat(
+//                    "[LLCLIENTVIEW]: Sending NameValue {0} for {1} {2} to {3}",
+//                    Util.UTF8.GetString(update.NameValue), data.Name, data.LocalId, Name);
+//
+//                m_log.DebugFormat(
+//                    "[LLCLIENTVIEW]: Sending state {0} for {1} {2} to {3}",
+//                    update.State, data.Name, data.LocalId, Name);
+            }
+            else
+            {
+                update.NameValue = Utils.EmptyBytes;
+
+                // The root part state is the canonical state for all parts of the object.  The other part states in the
+                // case for attachments may contain conflicting values that can end up crashing the viewer.
+                update.State = data.ParentGroup.RootPart.Shape.State;
+            }
+*/
+
+            if (part.ParentGroup.IsAttachment)
+            {
+                if (part.IsRoot)
+                {
+                    update.NameValue = Util.StringToBytes256("AttachItemID STRING RW SV " + part.ParentGroup.FromItemID);
+                }
+                else
+                    update.NameValue = Utils.EmptyBytes;
+
+                int st = (int)part.ParentGroup.AttachmentPoint;
+                update.State = (byte)(((st & 0xf0) >> 4) + ((st & 0x0f) << 4)); ;
+            }
+            else
+            {
+                update.NameValue = Utils.EmptyBytes;
+                update.State = part.Shape.State; // not sure about this
+            }
+
+            update.ObjectData = objectData;
+            update.ParentID = part.ParentID;
+            update.PathBegin = part.Shape.PathBegin;
+            update.PathCurve = part.Shape.PathCurve;
+            update.PathEnd = part.Shape.PathEnd;
+            update.PathRadiusOffset = part.Shape.PathRadiusOffset;
+            update.PathRevolutions = part.Shape.PathRevolutions;
+            update.PathScaleX = part.Shape.PathScaleX;
+            update.PathScaleY = part.Shape.PathScaleY;
+            update.PathShearX = part.Shape.PathShearX;
+            update.PathShearY = part.Shape.PathShearY;
+            update.PathSkew = part.Shape.PathSkew;
+            update.PathTaperX = part.Shape.PathTaperX;
+            update.PathTaperY = part.Shape.PathTaperY;
+            update.PathTwist = part.Shape.PathTwist;
+            update.PathTwistBegin = part.Shape.PathTwistBegin;
+            update.PCode = part.Shape.PCode;
+            update.ProfileBegin = part.Shape.ProfileBegin;
+            update.ProfileCurve = part.Shape.ProfileCurve;
+
+            ushort profileBegin = part.Shape.ProfileBegin;
+            ushort profileHollow = part.Shape.ProfileHollow;
+
+            if(part.Shape.SculptType == (byte)SculptType.Mesh) // filter out hack
+            {
+                update.ProfileCurve = (byte)(part.Shape.ProfileCurve & 0x0f);
+                // fix old values that confused viewers
+                if(profileBegin == 1)
+                    profileBegin = 9375;
+                if(profileHollow == 1)
+                    profileHollow = 27500;
+                // fix torus hole size Y that also confuse some viewers
+                if(update.ProfileCurve == (byte)ProfileShape.Circle && update.PathScaleY < 150)
+                       update.PathScaleY = 150;                    
+            }
+            else
+            {
+                update.ProfileCurve = part.Shape.ProfileCurve;
+            }
+
+            update.ProfileHollow = profileHollow;
+            update.ProfileBegin = profileBegin;
+            update.ProfileEnd = part.Shape.ProfileEnd;
+            update.PSBlock = part.ParticleSystem ?? Utils.EmptyBytes;
+            update.TextColor = part.GetTextColor().GetBytes(false);
+            update.TextureAnim = part.TextureAnimation ?? Utils.EmptyBytes;
+            update.TextureEntry = part.Shape.TextureEntry ?? Utils.EmptyBytes;
+            update.Scale = part.Shape.Scale;
+            update.Text = Util.StringToBytes(part.Text, 255);
+            update.MediaURL = Util.StringToBytes(part.MediaUrl, 255);
+
+            #region PrimFlags
+
+            PrimFlags flags = (PrimFlags)m_scene.Permissions.GenerateClientFlags(part, sp);
+
+            // Don't send the CreateSelected flag to everyone
+            flags &= ~PrimFlags.CreateSelected;
+
+            if (sp.UUID == part.OwnerID)
+            {
+                if (part.CreateSelected)
+                {
+                    // Only send this flag once, then unset it
+                    flags |= PrimFlags.CreateSelected;
+                    part.CreateSelected = false;
+                }
+            }
+
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Constructing client update for part {0} {1} with flags {2}, localId {3}",
+//                data.Name, update.FullID, flags, update.ID);
+
+            update.UpdateFlags = (uint)flags;
+
+            #endregion PrimFlags
+
+            if (part.Sound != UUID.Zero)
+            {
+                update.Sound = part.Sound;
+                update.OwnerID = part.OwnerID;
+                update.Gain = (float)part.SoundGain;
+                update.Radius = (float)part.SoundRadius;
+                update.Flags = part.SoundFlags;
+            }
+
+            switch ((PCode)part.Shape.PCode)
+            {
+                case PCode.Grass:
+                case PCode.Tree:
+                case PCode.NewTree:
+                    update.Data = new byte[] { part.Shape.State };
+                    break;
+                default:
+                    update.Data = Utils.EmptyBytes;
+                    break;
+            }
+
+            return update;
+        }
+
+        protected ObjectUpdateCompressedPacket.ObjectDataBlock CreateCompressedUpdateBlock(SceneObjectPart part, PrimUpdateFlags updateFlags)
+        {
+            // TODO: Implement this
+            return null;
+        }
+
+        public void SendNameReply(UUID profileId, string firstname, string lastname)
+        {
+            UUIDNameReplyPacket packet = (UUIDNameReplyPacket)PacketPool.Instance.GetPacket(PacketType.UUIDNameReply);
+            // TODO: don't create new blocks if recycling an old packet
+            packet.UUIDNameBlock = new UUIDNameReplyPacket.UUIDNameBlockBlock[1];
+            packet.UUIDNameBlock[0] = new UUIDNameReplyPacket.UUIDNameBlockBlock();
+            packet.UUIDNameBlock[0].ID = profileId;
+            packet.UUIDNameBlock[0].FirstName = Util.StringToBytes256(firstname);
+            packet.UUIDNameBlock[0].LastName = Util.StringToBytes256(lastname);
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public Dictionary<UUID, ulong> GetGroupPowers()
+        {
+            lock(m_groupPowers)
+            {
+                return new Dictionary<UUID, ulong>(m_groupPowers);
+            }
+        }
+
+        public void SetGroupPowers(Dictionary<UUID, ulong> powers)
+        {
+            lock(m_groupPowers)
+            {
+                m_groupPowers.Clear();
+                m_groupPowers = powers;
+            }
+        }
+
+        public ulong GetGroupPowers(UUID groupID)
+        {
+            lock(m_groupPowers)
+            {
+                if (m_groupPowers.ContainsKey(groupID))
+                    return m_groupPowers[groupID];
+            }
+            return 0;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// This is a different way of processing packets then ProcessInPacket
+        /// </summary>
+        protected virtual void RegisterLocalPacketHandlers()
+        {
+            AddLocalPacketHandler(PacketType.LogoutRequest, HandleLogout);
+
+            // If AgentUpdate is ever handled asynchronously, then we will also need to construct a new AgentUpdateArgs
+            // for each AgentUpdate packet.
+            AddLocalPacketHandler(PacketType.AgentUpdate, HandleAgentUpdate, false);
+
+            AddLocalPacketHandler(PacketType.ViewerEffect, HandleViewerEffect, false);
+            AddLocalPacketHandler(PacketType.VelocityInterpolateOff, HandleVelocityInterpolateOff, false);
+            AddLocalPacketHandler(PacketType.VelocityInterpolateOn, HandleVelocityInterpolateOn, false);
+            AddLocalPacketHandler(PacketType.AgentCachedTexture, HandleAgentTextureCached, false);
+            AddLocalPacketHandler(PacketType.MultipleObjectUpdate, HandleMultipleObjUpdate, false);
+            AddLocalPacketHandler(PacketType.MoneyTransferRequest, HandleMoneyTransferRequest, false);
+            AddLocalPacketHandler(PacketType.ParcelBuy, HandleParcelBuyRequest, false);
+            AddLocalPacketHandler(PacketType.UUIDGroupNameRequest, HandleUUIDGroupNameRequest);
+            AddLocalPacketHandler(PacketType.ObjectGroup, HandleObjectGroupRequest);
+            AddLocalPacketHandler(PacketType.GenericMessage, HandleGenericMessage);
+            AddLocalPacketHandler(PacketType.AvatarPropertiesRequest, HandleAvatarPropertiesRequest);
+            AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);
+            AddLocalPacketHandler(PacketType.AvatarPropertiesUpdate, HandlerAvatarPropertiesUpdate);
+            AddLocalPacketHandler(PacketType.ScriptDialogReply, HandlerScriptDialogReply);
+            AddLocalPacketHandler(PacketType.ImprovedInstantMessage, HandlerImprovedInstantMessage);
+            AddLocalPacketHandler(PacketType.AcceptFriendship, HandlerAcceptFriendship);
+            AddLocalPacketHandler(PacketType.DeclineFriendship, HandlerDeclineFriendship);
+            AddLocalPacketHandler(PacketType.TerminateFriendship, HandlerTerminateFriendship);
+            AddLocalPacketHandler(PacketType.RezObject, HandlerRezObject);
+            AddLocalPacketHandler(PacketType.DeRezObject, HandlerDeRezObject);
+            AddLocalPacketHandler(PacketType.RezRestoreToWorld, HandlerRezRestoreToWorld);
+            AddLocalPacketHandler(PacketType.ModifyLand, HandlerModifyLand);
+            AddLocalPacketHandler(PacketType.RegionHandshakeReply, HandlerRegionHandshakeReply, false);
+            AddLocalPacketHandler(PacketType.AgentWearablesRequest, HandlerAgentWearablesRequest);
+            AddLocalPacketHandler(PacketType.AgentSetAppearance, HandlerAgentSetAppearance);
+            AddLocalPacketHandler(PacketType.AgentIsNowWearing, HandlerAgentIsNowWearing);
+            AddLocalPacketHandler(PacketType.RezSingleAttachmentFromInv, HandlerRezSingleAttachmentFromInv);
+            AddLocalPacketHandler(PacketType.RezMultipleAttachmentsFromInv, HandleRezMultipleAttachmentsFromInv);
+            AddLocalPacketHandler(PacketType.DetachAttachmentIntoInv, HandleDetachAttachmentIntoInv);
+            AddLocalPacketHandler(PacketType.ObjectAttach, HandleObjectAttach);
+            AddLocalPacketHandler(PacketType.ObjectDetach, HandleObjectDetach);
+            AddLocalPacketHandler(PacketType.ObjectDrop, HandleObjectDrop);
+            AddLocalPacketHandler(PacketType.SetAlwaysRun, HandleSetAlwaysRun, false);
+            AddLocalPacketHandler(PacketType.CompleteAgentMovement, HandleCompleteAgentMovement);
+            AddLocalPacketHandler(PacketType.AgentAnimation, HandleAgentAnimation, false);
+            AddLocalPacketHandler(PacketType.AgentRequestSit, HandleAgentRequestSit);
+            AddLocalPacketHandler(PacketType.AgentSit, HandleAgentSit);
+            AddLocalPacketHandler(PacketType.SoundTrigger, HandleSoundTrigger);
+            AddLocalPacketHandler(PacketType.AvatarPickerRequest, HandleAvatarPickerRequest);
+            AddLocalPacketHandler(PacketType.AgentDataUpdateRequest, HandleAgentDataUpdateRequest);
+            AddLocalPacketHandler(PacketType.UserInfoRequest, HandleUserInfoRequest);
+            AddLocalPacketHandler(PacketType.UpdateUserInfo, HandleUpdateUserInfo);
+            AddLocalPacketHandler(PacketType.SetStartLocationRequest, HandleSetStartLocationRequest);
+            AddLocalPacketHandler(PacketType.AgentThrottle, HandleAgentThrottle, false);
+            AddLocalPacketHandler(PacketType.AgentPause, HandleAgentPause, false);
+            AddLocalPacketHandler(PacketType.AgentResume, HandleAgentResume, false);
+            AddLocalPacketHandler(PacketType.ForceScriptControlRelease, HandleForceScriptControlRelease);
+            AddLocalPacketHandler(PacketType.ObjectLink, HandleObjectLink);
+            AddLocalPacketHandler(PacketType.ObjectDelink, HandleObjectDelink);
+            AddLocalPacketHandler(PacketType.ObjectAdd, HandleObjectAdd);
+            AddLocalPacketHandler(PacketType.ObjectShape, HandleObjectShape);
+            AddLocalPacketHandler(PacketType.ObjectExtraParams, HandleObjectExtraParams);
+            AddLocalPacketHandler(PacketType.ObjectDuplicate, HandleObjectDuplicate);
+            AddLocalPacketHandler(PacketType.RequestMultipleObjects, HandleRequestMultipleObjects);
+            AddLocalPacketHandler(PacketType.ObjectSelect, HandleObjectSelect);
+            AddLocalPacketHandler(PacketType.ObjectDeselect, HandleObjectDeselect);
+            AddLocalPacketHandler(PacketType.ObjectPosition, HandleObjectPosition);
+            AddLocalPacketHandler(PacketType.ObjectScale, HandleObjectScale);
+            AddLocalPacketHandler(PacketType.ObjectRotation, HandleObjectRotation);
+            AddLocalPacketHandler(PacketType.ObjectFlagUpdate, HandleObjectFlagUpdate);
+
+            // Handle ObjectImage (TextureEntry) updates synchronously, since when updating multiple prim faces at once,
+            // some clients will send out a separate ObjectImage packet for each face
+            AddLocalPacketHandler(PacketType.ObjectImage, HandleObjectImage, false);
+
+            AddLocalPacketHandler(PacketType.ObjectGrab, HandleObjectGrab, false);
+            AddLocalPacketHandler(PacketType.ObjectGrabUpdate, HandleObjectGrabUpdate, false);
+            AddLocalPacketHandler(PacketType.ObjectDeGrab, HandleObjectDeGrab);
+            AddLocalPacketHandler(PacketType.ObjectSpinStart, HandleObjectSpinStart, false);
+            AddLocalPacketHandler(PacketType.ObjectSpinUpdate, HandleObjectSpinUpdate, false);
+            AddLocalPacketHandler(PacketType.ObjectSpinStop, HandleObjectSpinStop, false);
+            AddLocalPacketHandler(PacketType.ObjectDescription, HandleObjectDescription, false);
+            AddLocalPacketHandler(PacketType.ObjectName, HandleObjectName, false);
+            AddLocalPacketHandler(PacketType.ObjectPermissions, HandleObjectPermissions, false);
+            AddLocalPacketHandler(PacketType.Undo, HandleUndo, false);
+            AddLocalPacketHandler(PacketType.UndoLand, HandleLandUndo, false);
+            AddLocalPacketHandler(PacketType.Redo, HandleRedo, false);
+            AddLocalPacketHandler(PacketType.ObjectDuplicateOnRay, HandleObjectDuplicateOnRay);
+            AddLocalPacketHandler(PacketType.RequestObjectPropertiesFamily, HandleRequestObjectPropertiesFamily, false);
+            AddLocalPacketHandler(PacketType.ObjectIncludeInSearch, HandleObjectIncludeInSearch);
+            AddLocalPacketHandler(PacketType.ScriptAnswerYes, HandleScriptAnswerYes, false);
+            AddLocalPacketHandler(PacketType.ObjectClickAction, HandleObjectClickAction, false);
+            AddLocalPacketHandler(PacketType.ObjectMaterial, HandleObjectMaterial, false);
+            AddLocalPacketHandler(PacketType.RequestImage, HandleRequestImage, false);
+            AddLocalPacketHandler(PacketType.TransferRequest, HandleTransferRequest, false);
+            AddLocalPacketHandler(PacketType.AssetUploadRequest, HandleAssetUploadRequest);
+            AddLocalPacketHandler(PacketType.RequestXfer, HandleRequestXfer);
+            AddLocalPacketHandler(PacketType.SendXferPacket, HandleSendXferPacket);
+            AddLocalPacketHandler(PacketType.ConfirmXferPacket, HandleConfirmXferPacket);
+            AddLocalPacketHandler(PacketType.AbortXfer, HandleAbortXfer);
+            AddLocalPacketHandler(PacketType.CreateInventoryFolder, HandleCreateInventoryFolder);
+            AddLocalPacketHandler(PacketType.UpdateInventoryFolder, HandleUpdateInventoryFolder);
+            AddLocalPacketHandler(PacketType.MoveInventoryFolder, HandleMoveInventoryFolder);
+            AddLocalPacketHandler(PacketType.CreateInventoryItem, HandleCreateInventoryItem);
+            AddLocalPacketHandler(PacketType.LinkInventoryItem, HandleLinkInventoryItem);
+            AddLocalPacketHandler(PacketType.FetchInventory, HandleFetchInventory);
+            AddLocalPacketHandler(PacketType.FetchInventoryDescendents, HandleFetchInventoryDescendents);
+            AddLocalPacketHandler(PacketType.PurgeInventoryDescendents, HandlePurgeInventoryDescendents);
+            AddLocalPacketHandler(PacketType.UpdateInventoryItem, HandleUpdateInventoryItem);
+            AddLocalPacketHandler(PacketType.CopyInventoryItem, HandleCopyInventoryItem);
+            AddLocalPacketHandler(PacketType.MoveInventoryItem, HandleMoveInventoryItem);
+            AddLocalPacketHandler(PacketType.RemoveInventoryItem, HandleRemoveInventoryItem);
+            AddLocalPacketHandler(PacketType.RemoveInventoryFolder, HandleRemoveInventoryFolder);
+            AddLocalPacketHandler(PacketType.RemoveInventoryObjects, HandleRemoveInventoryObjects);
+            AddLocalPacketHandler(PacketType.RequestTaskInventory, HandleRequestTaskInventory);
+            AddLocalPacketHandler(PacketType.UpdateTaskInventory, HandleUpdateTaskInventory);
+            AddLocalPacketHandler(PacketType.RemoveTaskInventory, HandleRemoveTaskInventory);
+            AddLocalPacketHandler(PacketType.MoveTaskInventory, HandleMoveTaskInventory);
+            AddLocalPacketHandler(PacketType.RezScript, HandleRezScript);
+            AddLocalPacketHandler(PacketType.MapLayerRequest, HandleMapLayerRequest);
+            AddLocalPacketHandler(PacketType.MapBlockRequest, HandleMapBlockRequest);
+            AddLocalPacketHandler(PacketType.MapNameRequest, HandleMapNameRequest);
+            AddLocalPacketHandler(PacketType.TeleportLandmarkRequest, HandleTeleportLandmarkRequest);
+            AddLocalPacketHandler(PacketType.TeleportCancel, HandleTeleportCancel);
+            AddLocalPacketHandler(PacketType.TeleportLocationRequest, HandleTeleportLocationRequest);
+            AddLocalPacketHandler(PacketType.UUIDNameRequest, HandleUUIDNameRequest, false);
+            AddLocalPacketHandler(PacketType.RegionHandleRequest, HandleRegionHandleRequest, false);
+            AddLocalPacketHandler(PacketType.ParcelInfoRequest, HandleParcelInfoRequest);
+            AddLocalPacketHandler(PacketType.ParcelAccessListRequest, HandleParcelAccessListRequest, false);
+            AddLocalPacketHandler(PacketType.ParcelAccessListUpdate, HandleParcelAccessListUpdate, false);
+            AddLocalPacketHandler(PacketType.ParcelPropertiesRequest, HandleParcelPropertiesRequest, false);
+            AddLocalPacketHandler(PacketType.ParcelDivide, HandleParcelDivide);
+            AddLocalPacketHandler(PacketType.ParcelJoin, HandleParcelJoin);
+            AddLocalPacketHandler(PacketType.ParcelPropertiesUpdate, HandleParcelPropertiesUpdate);
+            AddLocalPacketHandler(PacketType.ParcelSelectObjects, HandleParcelSelectObjects);
+            AddLocalPacketHandler(PacketType.ParcelObjectOwnersRequest, HandleParcelObjectOwnersRequest);
+            AddLocalPacketHandler(PacketType.ParcelGodForceOwner, HandleParcelGodForceOwner);
+            AddLocalPacketHandler(PacketType.ParcelRelease, HandleParcelRelease);
+            AddLocalPacketHandler(PacketType.ParcelReclaim, HandleParcelReclaim);
+            AddLocalPacketHandler(PacketType.ParcelReturnObjects, HandleParcelReturnObjects);
+            AddLocalPacketHandler(PacketType.ParcelSetOtherCleanTime, HandleParcelSetOtherCleanTime);
+            AddLocalPacketHandler(PacketType.LandStatRequest, HandleLandStatRequest);
+            AddLocalPacketHandler(PacketType.ParcelDwellRequest, HandleParcelDwellRequest);
+            AddLocalPacketHandler(PacketType.EstateOwnerMessage, HandleEstateOwnerMessage);
+            AddLocalPacketHandler(PacketType.RequestRegionInfo, HandleRequestRegionInfo, false);
+            AddLocalPacketHandler(PacketType.EstateCovenantRequest, HandleEstateCovenantRequest);
+            AddLocalPacketHandler(PacketType.RequestGodlikePowers, HandleRequestGodlikePowers);
+            AddLocalPacketHandler(PacketType.GodKickUser, HandleGodKickUser);
+            AddLocalPacketHandler(PacketType.MoneyBalanceRequest, HandleMoneyBalanceRequest);
+            AddLocalPacketHandler(PacketType.EconomyDataRequest, HandleEconomyDataRequest);
+            AddLocalPacketHandler(PacketType.RequestPayPrice, HandleRequestPayPrice);
+            AddLocalPacketHandler(PacketType.ObjectSaleInfo, HandleObjectSaleInfo);
+            AddLocalPacketHandler(PacketType.ObjectBuy, HandleObjectBuy);
+            AddLocalPacketHandler(PacketType.GetScriptRunning, HandleGetScriptRunning);
+            AddLocalPacketHandler(PacketType.SetScriptRunning, HandleSetScriptRunning);
+            AddLocalPacketHandler(PacketType.ScriptReset, HandleScriptReset);
+            AddLocalPacketHandler(PacketType.ActivateGestures, HandleActivateGestures);
+            AddLocalPacketHandler(PacketType.DeactivateGestures, HandleDeactivateGestures);
+            AddLocalPacketHandler(PacketType.ObjectOwner, HandleObjectOwner);
+            AddLocalPacketHandler(PacketType.AgentFOV, HandleAgentFOV, false);
+            AddLocalPacketHandler(PacketType.ViewerStats, HandleViewerStats);
+            AddLocalPacketHandler(PacketType.MapItemRequest, HandleMapItemRequest, false);
+            AddLocalPacketHandler(PacketType.TransferAbort, HandleTransferAbort, false);
+            AddLocalPacketHandler(PacketType.MuteListRequest, HandleMuteListRequest, false);
+            AddLocalPacketHandler(PacketType.UseCircuitCode, HandleUseCircuitCode);
+            AddLocalPacketHandler(PacketType.CreateNewOutfitAttachments, HandleCreateNewOutfitAttachments);
+            AddLocalPacketHandler(PacketType.AgentHeightWidth, HandleAgentHeightWidth, false);
+            AddLocalPacketHandler(PacketType.InventoryDescendents, HandleInventoryDescendents);
+            AddLocalPacketHandler(PacketType.DirPlacesQuery, HandleDirPlacesQuery);
+            AddLocalPacketHandler(PacketType.DirFindQuery, HandleDirFindQuery);
+            AddLocalPacketHandler(PacketType.DirLandQuery, HandleDirLandQuery);
+            AddLocalPacketHandler(PacketType.DirPopularQuery, HandleDirPopularQuery);
+            AddLocalPacketHandler(PacketType.DirClassifiedQuery, HandleDirClassifiedQuery);
+            AddLocalPacketHandler(PacketType.EventInfoRequest, HandleEventInfoRequest);
+            AddLocalPacketHandler(PacketType.OfferCallingCard, HandleOfferCallingCard);
+            AddLocalPacketHandler(PacketType.AcceptCallingCard, HandleAcceptCallingCard);
+            AddLocalPacketHandler(PacketType.DeclineCallingCard, HandleDeclineCallingCard);
+            AddLocalPacketHandler(PacketType.ActivateGroup, HandleActivateGroup);
+            AddLocalPacketHandler(PacketType.GroupTitlesRequest, HandleGroupTitlesRequest);
+            AddLocalPacketHandler(PacketType.GroupProfileRequest, HandleGroupProfileRequest);
+            AddLocalPacketHandler(PacketType.GroupMembersRequest, HandleGroupMembersRequest);
+            AddLocalPacketHandler(PacketType.GroupRoleDataRequest, HandleGroupRoleDataRequest);
+            AddLocalPacketHandler(PacketType.GroupRoleMembersRequest, HandleGroupRoleMembersRequest);
+            AddLocalPacketHandler(PacketType.CreateGroupRequest, HandleCreateGroupRequest);
+            AddLocalPacketHandler(PacketType.UpdateGroupInfo, HandleUpdateGroupInfo);
+            AddLocalPacketHandler(PacketType.SetGroupAcceptNotices, HandleSetGroupAcceptNotices);
+            AddLocalPacketHandler(PacketType.GroupTitleUpdate, HandleGroupTitleUpdate);
+            AddLocalPacketHandler(PacketType.ParcelDeedToGroup, HandleParcelDeedToGroup);
+            AddLocalPacketHandler(PacketType.GroupNoticesListRequest, HandleGroupNoticesListRequest);
+            AddLocalPacketHandler(PacketType.GroupNoticeRequest, HandleGroupNoticeRequest);
+            AddLocalPacketHandler(PacketType.GroupRoleUpdate, HandleGroupRoleUpdate);
+            AddLocalPacketHandler(PacketType.GroupRoleChanges, HandleGroupRoleChanges);
+            AddLocalPacketHandler(PacketType.JoinGroupRequest, HandleJoinGroupRequest);
+            AddLocalPacketHandler(PacketType.LeaveGroupRequest, HandleLeaveGroupRequest);
+            AddLocalPacketHandler(PacketType.EjectGroupMemberRequest, HandleEjectGroupMemberRequest);
+            AddLocalPacketHandler(PacketType.InviteGroupRequest, HandleInviteGroupRequest);
+            AddLocalPacketHandler(PacketType.StartLure, HandleStartLure);
+            AddLocalPacketHandler(PacketType.TeleportLureRequest, HandleTeleportLureRequest);
+            AddLocalPacketHandler(PacketType.ClassifiedInfoRequest, HandleClassifiedInfoRequest);
+            AddLocalPacketHandler(PacketType.ClassifiedInfoUpdate, HandleClassifiedInfoUpdate);
+            AddLocalPacketHandler(PacketType.ClassifiedDelete, HandleClassifiedDelete);
+            AddLocalPacketHandler(PacketType.ClassifiedGodDelete, HandleClassifiedGodDelete);
+            AddLocalPacketHandler(PacketType.EventGodDelete, HandleEventGodDelete);
+            AddLocalPacketHandler(PacketType.EventNotificationAddRequest, HandleEventNotificationAddRequest);
+            AddLocalPacketHandler(PacketType.EventNotificationRemoveRequest, HandleEventNotificationRemoveRequest);
+            AddLocalPacketHandler(PacketType.RetrieveInstantMessages, HandleRetrieveInstantMessages);
+            AddLocalPacketHandler(PacketType.PickDelete, HandlePickDelete);
+            AddLocalPacketHandler(PacketType.PickGodDelete, HandlePickGodDelete);
+            AddLocalPacketHandler(PacketType.PickInfoUpdate, HandlePickInfoUpdate);
+            AddLocalPacketHandler(PacketType.AvatarNotesUpdate, HandleAvatarNotesUpdate);
+            AddLocalPacketHandler(PacketType.AvatarInterestsUpdate, HandleAvatarInterestsUpdate);
+            AddLocalPacketHandler(PacketType.GrantUserRights, HandleGrantUserRights);
+            AddLocalPacketHandler(PacketType.PlacesQuery, HandlePlacesQuery);
+            AddLocalPacketHandler(PacketType.UpdateMuteListEntry, HandleUpdateMuteListEntry);
+            AddLocalPacketHandler(PacketType.RemoveMuteListEntry, HandleRemoveMuteListEntry);
+            AddLocalPacketHandler(PacketType.UserReport, HandleUserReport);
+            AddLocalPacketHandler(PacketType.FindAgent, HandleFindAgent);
+            AddLocalPacketHandler(PacketType.TrackAgent, HandleTrackAgent);
+            AddLocalPacketHandler(PacketType.GodUpdateRegionInfo, HandleGodUpdateRegionInfoUpdate);
+            AddLocalPacketHandler(PacketType.GodlikeMessage, HandleGodlikeMessage);
+            AddLocalPacketHandler(PacketType.StateSave, HandleSaveStatePacket);
+            AddLocalPacketHandler(PacketType.GroupAccountDetailsRequest, HandleGroupAccountDetailsRequest);
+            AddLocalPacketHandler(PacketType.GroupAccountSummaryRequest, HandleGroupAccountSummaryRequest);
+            AddLocalPacketHandler(PacketType.GroupAccountTransactionsRequest, HandleGroupTransactionsDetailsRequest);
+            AddLocalPacketHandler(PacketType.FreezeUser, HandleFreezeUser);
+            AddLocalPacketHandler(PacketType.EjectUser, HandleEjectUser);
+            AddLocalPacketHandler(PacketType.ParcelBuyPass, HandleParcelBuyPass);
+            AddLocalPacketHandler(PacketType.ParcelGodMarkAsContent, HandleParcelGodMarkAsContent);
+            AddLocalPacketHandler(PacketType.GroupActiveProposalsRequest, HandleGroupActiveProposalsRequest);
+            AddLocalPacketHandler(PacketType.GroupVoteHistoryRequest, HandleGroupVoteHistoryRequest);
+            AddLocalPacketHandler(PacketType.SimWideDeletes, HandleSimWideDeletes);
+            AddLocalPacketHandler(PacketType.SendPostcard, HandleSendPostcard);
+            AddLocalPacketHandler(PacketType.ChangeInventoryItemFlags, HandleChangeInventoryItemFlags);
+            AddLocalPacketHandler(PacketType.RevokePermissions, HandleRevokePermissions);
+            AddGenericPacketHandler("autopilot", HandleAutopilot);
+        }
+
+        #region Packet Handlers
+
+        public int TotalAgentUpdates { get; set; }
+
+        #region Scene/Avatar
+
+        // Threshold for body rotation to be a significant agent update
+        // use the abs of cos
+        private const float QDELTABody = 1.0f - 0.00005f;
+        private const float QDELTAHead = 1.0f - 0.00005f;
+        // Threshold for camera rotation to be a significant agent update
+        private const float VDELTA = 0.01f;
+
+        /// <summary>
+        /// This checks the update significance against the last update made.
+        /// </summary>
+        /// <remarks>Can only be called by one thread at a time</remarks>
+        /// <returns></returns>
+        /// <param name='x'></param>
+        public bool CheckAgentUpdateSignificance(AgentUpdatePacket.AgentDataBlock x)
+        {
+            return CheckAgentMovementUpdateSignificance(x) || CheckAgentCameraUpdateSignificance(x);
+        }
+
+        /// <summary>
+        /// This checks the movement/state update significance against the last update made.
+        /// </summary>
+        /// <remarks>Can only be called by one thread at a time</remarks>
+        /// <returns></returns>
+        /// <param name='x'></param>
+        private bool CheckAgentMovementUpdateSignificance(AgentUpdatePacket.AgentDataBlock x)
+        {
+            if(
+                (x.ControlFlags != m_thisAgentUpdateArgs.ControlFlags)   // significant if control flags changed
+//                || ((x.ControlFlags & (uint)AgentManager.ControlFlags.AGENT_CONTROL_FLY) != 0 &&
+//                    (x.ControlFlags & 0x3f8dfff) != 0) // we need to rotate the av on fly
+                || x.ControlFlags != (byte)AgentManager.ControlFlags.NONE// actually all movement controls need to pass
+                || (x.Flags != m_thisAgentUpdateArgs.Flags)                 // significant if Flags changed
+                || (x.State != m_thisAgentUpdateArgs.State)                 // significant if Stats changed
+                || (Math.Abs(x.Far - m_thisAgentUpdateArgs.Far) >= 32)      // significant if far distance changed
+                )
+                return true;
+
+           float qdelta1 = Math.Abs(Quaternion.Dot(x.BodyRotation, m_thisAgentUpdateArgs.BodyRotation));
+           //qdelta2 = Math.Abs(Quaternion.Dot(x.HeadRotation, m_thisAgentUpdateArgs.HeadRotation));
+
+           if(
+                qdelta1 < QDELTABody // significant if body rotation above(below cos) threshold
+                // Ignoring head rotation altogether, because it's not being used for anything interesting up the stack
+                // || qdelta2 < QDELTAHead // significant if head rotation above(below cos) threshold
+                )
+                return true;
+
+            return false;
+        }
+
+        /// <summary>
+        /// This checks the camera update significance against the last update made.
+        /// </summary>
+        /// <remarks>Can only be called by one thread at a time</remarks>
+        /// <returns></returns>
+        /// <param name='x'></param>
+        private bool CheckAgentCameraUpdateSignificance(AgentUpdatePacket.AgentDataBlock x)
+        {
+            if(Math.Abs(x.CameraCenter.X - m_thisAgentUpdateArgs.CameraCenter.X) > VDELTA ||
+               Math.Abs(x.CameraCenter.Y - m_thisAgentUpdateArgs.CameraCenter.Y) > VDELTA ||
+               Math.Abs(x.CameraCenter.Z - m_thisAgentUpdateArgs.CameraCenter.Z) > VDELTA ||
+
+               Math.Abs(x.CameraAtAxis.X - m_thisAgentUpdateArgs.CameraAtAxis.X) > VDELTA ||
+               Math.Abs(x.CameraAtAxis.Y - m_thisAgentUpdateArgs.CameraAtAxis.Y) > VDELTA ||
+//               Math.Abs(x.CameraAtAxis.Z - m_thisAgentUpdateArgs.CameraAtAxis.Z) > VDELTA ||
+
+               Math.Abs(x.CameraLeftAxis.X - m_thisAgentUpdateArgs.CameraLeftAxis.X) > VDELTA ||
+               Math.Abs(x.CameraLeftAxis.Y - m_thisAgentUpdateArgs.CameraLeftAxis.Y) > VDELTA ||
+//               Math.Abs(x.CameraLeftAxis.Z - m_thisAgentUpdateArgs.CameraLeftAxis.Z) > VDELTA ||
+
+               Math.Abs(x.CameraUpAxis.X - m_thisAgentUpdateArgs.CameraUpAxis.X) > VDELTA ||
+               Math.Abs(x.CameraUpAxis.Y - m_thisAgentUpdateArgs.CameraUpAxis.Y) > VDELTA
+//               Math.Abs(x.CameraLeftAxis.Z - m_thisAgentUpdateArgs.CameraLeftAxis.Z) > VDELTA ||
+            )
+                return true;
+
+            return false;
+        }
+
+        private bool HandleAgentUpdate(IClientAPI sender, Packet packet)
+        {
+            AgentUpdatePacket agentUpdate = (AgentUpdatePacket)packet;
+            AgentUpdatePacket.AgentDataBlock x = agentUpdate.AgentData;
+
+            if (x.AgentID != AgentId || x.SessionID != SessionId)
+            {
+                PacketPool.Instance.ReturnPacket(packet);
+                return false;
+            }
+
+            uint seq = packet.Header.Sequence;
+
+            TotalAgentUpdates++;
+            // dont let ignored updates pollute this throttles
+            if(SceneAgent == null || SceneAgent.IsChildAgent ||
+                    SceneAgent.IsInTransit || seq <= m_thisAgentUpdateArgs.lastpacketSequence )
+            {
+                // throttle reset is done at MoveAgentIntoRegion()
+                // called by scenepresence on completemovement
+                PacketPool.Instance.ReturnPacket(packet);
+                return true;
+            }
+
+            m_thisAgentUpdateArgs.lastpacketSequence = seq;
+
+            bool movement = CheckAgentMovementUpdateSignificance(x);
+            bool camera = CheckAgentCameraUpdateSignificance(x);
+
+            // Was there a significant movement/state change?
+            if (movement)
+            {
+                m_thisAgentUpdateArgs.BodyRotation = x.BodyRotation;
+                m_thisAgentUpdateArgs.ControlFlags = x.ControlFlags;
+                m_thisAgentUpdateArgs.Far = x.Far;
+                m_thisAgentUpdateArgs.Flags = x.Flags;
+                m_thisAgentUpdateArgs.HeadRotation = x.HeadRotation;
+                m_thisAgentUpdateArgs.State = x.State;
+
+                m_thisAgentUpdateArgs.NeedsCameraCollision = !camera;
+
+                UpdateAgent handlerAgentUpdate = OnAgentUpdate;
+                UpdateAgent handlerPreAgentUpdate = OnPreAgentUpdate;
+
+                if (handlerPreAgentUpdate != null)
+                    OnPreAgentUpdate(this, m_thisAgentUpdateArgs);
+
+                if (handlerAgentUpdate != null)
+                    OnAgentUpdate(this, m_thisAgentUpdateArgs);
+
+            }
+
+            // Was there a significant camera(s) change?
+            if (camera)
+            {
+                m_thisAgentUpdateArgs.CameraAtAxis = x.CameraAtAxis;
+                m_thisAgentUpdateArgs.CameraCenter = x.CameraCenter;
+                m_thisAgentUpdateArgs.CameraLeftAxis = x.CameraLeftAxis;
+                m_thisAgentUpdateArgs.CameraUpAxis = x.CameraUpAxis;
+
+                m_thisAgentUpdateArgs.NeedsCameraCollision = true;
+
+                UpdateAgent handlerAgentCameraUpdate = OnAgentCameraUpdate;
+
+                if (handlerAgentCameraUpdate != null)
+                    handlerAgentCameraUpdate(this, m_thisAgentUpdateArgs);
+
+            }
+
+            PacketPool.Instance.ReturnPacket(packet);
+
+            return true;
+        }
+
+        private bool HandleMoneyTransferRequest(IClientAPI sender, Packet Pack)
+        {
+            MoneyTransferRequestPacket money = (MoneyTransferRequestPacket)Pack;
+            // validate the agent owns the agentID and sessionID
+            if (money.MoneyData.SourceID == sender.AgentId && money.AgentData.AgentID == sender.AgentId &&
+                money.AgentData.SessionID == sender.SessionId)
+            {
+                MoneyTransferRequest handlerMoneyTransferRequest = OnMoneyTransferRequest;
+                if (handlerMoneyTransferRequest != null)
+                {
+                    handlerMoneyTransferRequest(money.MoneyData.SourceID, money.MoneyData.DestID,
+                                                money.MoneyData.Amount, money.MoneyData.TransactionType,
+                                                Util.FieldToString(money.MoneyData.Description));
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool HandleParcelGodMarkAsContent(IClientAPI client, Packet Packet)
+        {
+            ParcelGodMarkAsContentPacket ParcelGodMarkAsContent =
+                (ParcelGodMarkAsContentPacket)Packet;
+
+            if(SessionId != ParcelGodMarkAsContent.AgentData.SessionID || AgentId != ParcelGodMarkAsContent.AgentData.AgentID)
+                return false;
+
+            ParcelGodMark ParcelGodMarkAsContentHandler = OnParcelGodMark;
+            if (ParcelGodMarkAsContentHandler != null)
+            {
+                ParcelGodMarkAsContentHandler(this,
+                                 ParcelGodMarkAsContent.AgentData.AgentID,
+                                 ParcelGodMarkAsContent.ParcelData.LocalID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleFreezeUser(IClientAPI client, Packet Packet)
+        {
+            FreezeUserPacket FreezeUser = (FreezeUserPacket)Packet;
+
+            if(SessionId != FreezeUser.AgentData.SessionID || AgentId != FreezeUser.AgentData.AgentID)
+                return false;
+
+            FreezeUserUpdate FreezeUserHandler = OnParcelFreezeUser;
+            if (FreezeUserHandler != null)
+            {
+                FreezeUserHandler(this,
+                                  FreezeUser.AgentData.AgentID,
+                                  FreezeUser.Data.Flags,
+                                  FreezeUser.Data.TargetID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleEjectUser(IClientAPI client, Packet Packet)
+        {
+            EjectUserPacket EjectUser =
+                (EjectUserPacket)Packet;
+
+            if(SessionId != EjectUser.AgentData.SessionID || AgentId != EjectUser.AgentData.AgentID)
+                return false;
+
+            EjectUserUpdate EjectUserHandler = OnParcelEjectUser;
+            if (EjectUserHandler != null)
+            {
+                EjectUserHandler(this,
+                                 EjectUser.AgentData.AgentID,
+                                 EjectUser.Data.Flags,
+                                 EjectUser.Data.TargetID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleParcelBuyPass(IClientAPI client, Packet Packet)
+        {
+            ParcelBuyPassPacket ParcelBuyPass =
+                (ParcelBuyPassPacket)Packet;
+
+            if(SessionId != ParcelBuyPass.AgentData.SessionID || AgentId != ParcelBuyPass.AgentData.AgentID)
+                return false;
+
+            ParcelBuyPass ParcelBuyPassHandler = OnParcelBuyPass;
+            if (ParcelBuyPassHandler != null)
+            {
+                ParcelBuyPassHandler(this,
+                                 ParcelBuyPass.AgentData.AgentID,
+                                 ParcelBuyPass.ParcelData.LocalID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleParcelBuyRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelBuyPacket parcel = (ParcelBuyPacket)Pack;
+            if (parcel.AgentData.AgentID == AgentId && parcel.AgentData.SessionID == SessionId)
+            {
+                ParcelBuy handlerParcelBuy = OnParcelBuy;
+                if (handlerParcelBuy != null)
+                {
+                    handlerParcelBuy(parcel.AgentData.AgentID, parcel.Data.GroupID, parcel.Data.Final,
+                                     parcel.Data.IsGroupOwned,
+                                     parcel.Data.RemoveContribution, parcel.Data.LocalID, parcel.ParcelData.Area,
+                                     parcel.ParcelData.Price,
+                                     false);
+                }
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleUUIDGroupNameRequest(IClientAPI sender, Packet Pack)
+        {
+            ScenePresence sp = (ScenePresence)SceneAgent;
+            if(sp == null || sp.IsDeleted || (sp.IsInTransit && !sp.IsInLocalTransit))
+                return true;
+
+            UUIDGroupNameRequestPacket upack = (UUIDGroupNameRequestPacket)Pack;
+
+            for (int i = 0; i < upack.UUIDNameBlock.Length; i++)
+            {
+                UUIDNameRequest handlerUUIDGroupNameRequest = OnUUIDGroupNameRequest;
+                if (handlerUUIDGroupNameRequest != null)
+                {
+                    handlerUUIDGroupNameRequest(upack.UUIDNameBlock[i].ID, this);
+                }
+            }
+
+            return true;
+        }
+
+        public bool HandleGenericMessage(IClientAPI sender, Packet pack)
+        {
+            GenericMessagePacket gmpack = (GenericMessagePacket)pack;
+            if (m_genericPacketHandlers.Count == 0) return false;
+            if (gmpack.AgentData.SessionID != SessionId) return false;
+
+            GenericMessage handlerGenericMessage = null;
+
+            string method = Util.FieldToString(gmpack.MethodData.Method).ToLower().Trim();
+
+            if (m_genericPacketHandlers.TryGetValue(method, out handlerGenericMessage))
+            {
+                List<string> msg = new List<string>();
+                List<byte[]> msgBytes = new List<byte[]>();
+
+                if (handlerGenericMessage != null)
+                {
+                    foreach (GenericMessagePacket.ParamListBlock block in gmpack.ParamList)
+                    {
+                        msg.Add(Util.FieldToString(block.Parameter));
+                        msgBytes.Add(block.Parameter);
+                    }
+                    try
+                    {
+                        if (OnBinaryGenericMessage != null)
+                        {
+                            OnBinaryGenericMessage(this, method, msgBytes.ToArray());
+                        }
+                        handlerGenericMessage(sender, method, msg);
+                        return true;
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[LLCLIENTVIEW]: Exeception when handling generic message {0}{1}", e.Message, e.StackTrace);
+                    }
+                }
+            }
+
+            //m_log.Debug("[LLCLIENTVIEW]: Not handling GenericMessage with method-type of: " + method);
+            return false;
+        }
+
+        public bool HandleObjectGroupRequest(IClientAPI sender, Packet Pack)
+        {
+            ObjectGroupPacket ogpack = (ObjectGroupPacket)Pack;
+            if (ogpack.AgentData.SessionID != SessionId) return false;
+
+            RequestObjectPropertiesFamily handlerObjectGroupRequest = OnObjectGroupRequest;
+            if (handlerObjectGroupRequest != null)
+            {
+                for (int i = 0; i < ogpack.ObjectData.Length; i++)
+                {
+                    handlerObjectGroupRequest(this, ogpack.AgentData.GroupID, ogpack.ObjectData[i].ObjectLocalID, UUID.Zero);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleViewerEffect(IClientAPI sender, Packet Pack)
+        {
+            ViewerEffectPacket viewer = (ViewerEffectPacket)Pack;
+            if (viewer.AgentData.SessionID != SessionId) return false;
+            ViewerEffectEventHandler handlerViewerEffect = OnViewerEffect;
+            if (handlerViewerEffect != null)
+            {
+                int length = viewer.Effect.Length;
+                List<ViewerEffectEventHandlerArg> args = new List<ViewerEffectEventHandlerArg>(length);
+                for (int i = 0; i < length; i++)
+                {
+                    //copy the effects block arguments into the event handler arg.
+                    ViewerEffectEventHandlerArg argument = new ViewerEffectEventHandlerArg();
+                    argument.AgentID = viewer.Effect[i].AgentID;
+                    argument.Color = viewer.Effect[i].Color;
+                    argument.Duration = viewer.Effect[i].Duration;
+                    argument.ID = viewer.Effect[i].ID;
+                    argument.Type = viewer.Effect[i].Type;
+                    argument.TypeData = viewer.Effect[i].TypeData;
+                    args.Add(argument);
+                }
+
+                handlerViewerEffect(sender, args);
+            }
+
+            return true;
+        }
+
+        private bool HandleVelocityInterpolateOff(IClientAPI sender, Packet Pack)
+        {
+            VelocityInterpolateOffPacket p = (VelocityInterpolateOffPacket)Pack;
+            if (p.AgentData.SessionID != SessionId ||
+                p.AgentData.AgentID != AgentId)
+                return true;
+
+//            m_VelocityInterpolate = false;
+            return true;
+        }
+
+        private bool HandleVelocityInterpolateOn(IClientAPI sender, Packet Pack)
+        {
+            VelocityInterpolateOnPacket p = (VelocityInterpolateOnPacket)Pack;
+            if (p.AgentData.SessionID != SessionId ||
+                p.AgentData.AgentID != AgentId)
+                return true;
+
+//            m_VelocityInterpolate = true;
+            return true;
+        }
+
+
+        private bool HandleAvatarPropertiesRequest(IClientAPI sender, Packet Pack)
+        {
+            AvatarPropertiesRequestPacket avatarProperties = (AvatarPropertiesRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avatarProperties.AgentData.SessionID != SessionId ||
+                    avatarProperties.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RequestAvatarProperties handlerRequestAvatarProperties = OnRequestAvatarProperties;
+            if (handlerRequestAvatarProperties != null)
+            {
+                handlerRequestAvatarProperties(this, avatarProperties.AgentData.AvatarID);
+            }
+            return true;
+        }
+
+        private bool HandleChatFromViewer(IClientAPI sender, Packet Pack)
+        {
+            ChatFromViewerPacket inchatpack = (ChatFromViewerPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (inchatpack.AgentData.SessionID != SessionId ||
+                    inchatpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            string fromName = String.Empty; //ClientAvatar.firstname + " " + ClientAvatar.lastname;
+            byte[] message = inchatpack.ChatData.Message;
+            byte type = inchatpack.ChatData.Type;
+            Vector3 fromPos = new Vector3(); // ClientAvatar.Pos;
+            // UUID fromAgentID = AgentId;
+
+            int channel = inchatpack.ChatData.Channel;
+
+            if (OnChatFromClient != null)
+            {
+                OSChatMessage args = new OSChatMessage();
+                args.Channel = channel;
+                args.From = fromName;
+                args.Message = Utils.BytesToString(message);
+                args.Type = (ChatTypeEnum)type;
+                args.Position = fromPos;
+
+                args.Scene = Scene;
+                args.Sender = this;
+                args.SenderUUID = this.AgentId;
+
+                ChatMessage handlerChatFromClient = OnChatFromClient;
+                if (handlerChatFromClient != null)
+                    handlerChatFromClient(this, args);
+            }
+            return true;
+        }
+
+        private bool HandlerAvatarPropertiesUpdate(IClientAPI sender, Packet Pack)
+        {
+            AvatarPropertiesUpdatePacket avatarProps = (AvatarPropertiesUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avatarProps.AgentData.SessionID != SessionId ||
+                    avatarProps.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UpdateAvatarProperties handlerUpdateAvatarProperties = OnUpdateAvatarProperties;
+            if (handlerUpdateAvatarProperties != null)
+            {
+                AvatarPropertiesUpdatePacket.PropertiesDataBlock Properties = avatarProps.PropertiesData;
+                UserProfileData UserProfile = new UserProfileData();
+                UserProfile.ID = AgentId;
+                UserProfile.AboutText = Utils.BytesToString(Properties.AboutText);
+                UserProfile.FirstLifeAboutText = Utils.BytesToString(Properties.FLAboutText);
+                UserProfile.FirstLifeImage = Properties.FLImageID;
+                UserProfile.Image = Properties.ImageID;
+                UserProfile.ProfileUrl = Utils.BytesToString(Properties.ProfileURL);
+                UserProfile.UserFlags &= ~3;
+                UserProfile.UserFlags |= Properties.AllowPublish ? 1 : 0;
+                UserProfile.UserFlags |= Properties.MaturePublish ? 2 : 0;
+
+                handlerUpdateAvatarProperties(this, UserProfile);
+            }
+            return true;
+        }
+
+        private bool HandlerScriptDialogReply(IClientAPI sender, Packet Pack)
+        {
+            ScriptDialogReplyPacket rdialog = (ScriptDialogReplyPacket)Pack;
+
+            //m_log.DebugFormat("[CLIENT]: Received ScriptDialogReply from {0}", rdialog.Data.ObjectID);
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rdialog.AgentData.SessionID != SessionId ||
+                    rdialog.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            int ch = rdialog.Data.ChatChannel;
+            byte[] msg = rdialog.Data.ButtonLabel;
+            if (OnChatFromClient != null)
+            {
+                OSChatMessage args = new OSChatMessage();
+                args.Channel = ch;
+                args.From = String.Empty;
+                args.Message = Utils.BytesToString(msg);
+                args.Type = ChatTypeEnum.Region; //Behaviour in SL is that the response can be heard from any distance
+                args.Position = new Vector3();
+                args.Scene = Scene;
+                args.Sender = this;
+                ChatMessage handlerChatFromClient2 = OnChatFromClient;
+                if (handlerChatFromClient2 != null)
+                    handlerChatFromClient2(this, args);
+            }
+
+            return true;
+        }
+
+        private bool HandlerImprovedInstantMessage(IClientAPI sender, Packet Pack)
+        {
+            ImprovedInstantMessagePacket msgpack = (ImprovedInstantMessagePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (msgpack.AgentData.SessionID != SessionId ||
+                    msgpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            string IMfromName = Util.FieldToString(msgpack.MessageBlock.FromAgentName);
+            string IMmessage = Utils.BytesToString(msgpack.MessageBlock.Message);
+            ImprovedInstantMessage handlerInstantMessage = OnInstantMessage;
+
+            if (handlerInstantMessage != null)
+            {
+                GridInstantMessage im = new GridInstantMessage(Scene,
+                        msgpack.AgentData.AgentID,
+                        IMfromName,
+                        msgpack.MessageBlock.ToAgentID,
+                        msgpack.MessageBlock.Dialog,
+                        msgpack.MessageBlock.FromGroup,
+                        IMmessage,
+                        msgpack.MessageBlock.ID,
+                        msgpack.MessageBlock.Offline != 0 ? true : false,
+                        msgpack.MessageBlock.Position,
+                        msgpack.MessageBlock.BinaryBucket,
+                        true);
+
+                handlerInstantMessage(this, im);
+            }
+            return true;
+
+        }
+
+        private bool HandlerAcceptFriendship(IClientAPI sender, Packet Pack)
+        {
+            AcceptFriendshipPacket afriendpack = (AcceptFriendshipPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (afriendpack.AgentData.SessionID != SessionId ||
+                    afriendpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            // My guess is this is the folder to stick the calling card into
+            List<UUID> callingCardFolders = new List<UUID>();
+
+            UUID transactionID = afriendpack.TransactionBlock.TransactionID;
+
+            for (int fi = 0; fi < afriendpack.FolderData.Length; fi++)
+            {
+                callingCardFolders.Add(afriendpack.FolderData[fi].FolderID);
+            }
+
+            FriendActionDelegate handlerApproveFriendRequest = OnApproveFriendRequest;
+            if (handlerApproveFriendRequest != null)
+            {
+                handlerApproveFriendRequest(this, transactionID, callingCardFolders);
+            }
+
+            return true;
+        }
+
+        private bool HandlerDeclineFriendship(IClientAPI sender, Packet Pack)
+        {
+            DeclineFriendshipPacket dfriendpack = (DeclineFriendshipPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dfriendpack.AgentData.SessionID != SessionId ||
+                    dfriendpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnDenyFriendRequest != null)
+            {
+                OnDenyFriendRequest(this,
+                                    dfriendpack.TransactionBlock.TransactionID,
+                                    null);
+            }
+            return true;
+        }
+
+        private bool HandlerTerminateFriendship(IClientAPI sender, Packet Pack)
+        {
+            TerminateFriendshipPacket tfriendpack = (TerminateFriendshipPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (tfriendpack.AgentData.SessionID != SessionId ||
+                    tfriendpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UUID exFriendID = tfriendpack.ExBlock.OtherID;
+            FriendshipTermination TerminateFriendshipHandler = OnTerminateFriendship;
+            if (TerminateFriendshipHandler != null)
+            {
+                TerminateFriendshipHandler(this, exFriendID);
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool HandleFindAgent(IClientAPI client, Packet Packet)
+        {
+            FindAgentPacket FindAgent =
+                (FindAgentPacket)Packet;
+
+            FindAgentUpdate FindAgentHandler = OnFindAgent;
+            if (FindAgentHandler != null)
+            {
+                FindAgentHandler(this,FindAgent.AgentBlock.Hunter,FindAgent.AgentBlock.Prey);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleTrackAgent(IClientAPI client, Packet Packet)
+        {
+            TrackAgentPacket TrackAgent =
+                (TrackAgentPacket)Packet;
+
+            TrackAgentUpdate TrackAgentHandler = OnTrackAgent;
+            if (TrackAgentHandler != null)
+            {
+                TrackAgentHandler(this,
+                                  TrackAgent.AgentData.AgentID,
+                                  TrackAgent.TargetData.PreyID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandlerRezObject(IClientAPI sender, Packet Pack)
+        {
+            RezObjectPacket rezPacket = (RezObjectPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rezPacket.AgentData.SessionID != SessionId ||
+                    rezPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RezObject handlerRezObject = OnRezObject;
+            if (handlerRezObject != null)
+            {
+                UUID rezGroupID = rezPacket.AgentData.GroupID;
+                if(!IsGroupMember(rezGroupID))
+                    rezGroupID = UUID.Zero;
+                handlerRezObject(this, rezPacket.InventoryData.ItemID, rezGroupID, rezPacket.RezData.RayEnd,
+                                rezPacket.RezData.RayStart, rezPacket.RezData.RayTargetID,
+                                rezPacket.RezData.BypassRaycast, rezPacket.RezData.RayEndIsIntersection,
+                                rezPacket.RezData.RezSelected, rezPacket.RezData.RemoveItem,
+                                rezPacket.RezData.FromTaskID);
+            }
+            return true;
+        }
+
+        private bool HandlerDeRezObject(IClientAPI sender, Packet Pack)
+        {
+            DeRezObjectPacket DeRezPacket = (DeRezObjectPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (DeRezPacket.AgentData.SessionID != SessionId ||
+                    DeRezPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DeRezObject handlerDeRezObject = OnDeRezObject;
+            if (handlerDeRezObject != null)
+            {
+                List<uint> deRezIDs = new List<uint>();
+
+                foreach (DeRezObjectPacket.ObjectDataBlock data in
+                    DeRezPacket.ObjectData)
+                {
+                    deRezIDs.Add(data.ObjectLocalID);
+                }
+                // It just so happens that the values on the DeRezAction enumerator match the Destination
+                // values given by a Second Life client
+                handlerDeRezObject(this, deRezIDs,
+                                   DeRezPacket.AgentBlock.GroupID,
+                                   (DeRezAction)DeRezPacket.AgentBlock.Destination,
+                                   DeRezPacket.AgentBlock.DestinationID);
+
+            }
+            return true;
+        }
+
+        private bool HandlerRezRestoreToWorld(IClientAPI sender, Packet Pack)
+        {
+            RezRestoreToWorldPacket restore = (RezRestoreToWorldPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (restore.AgentData.SessionID != SessionId ||
+                    restore.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RezRestoreToWorld handlerRezRestoreToWorld = OnRezRestoreToWorld;
+            if (handlerRezRestoreToWorld != null)
+                handlerRezRestoreToWorld(this, restore.InventoryData.ItemID);
+
+            return true;
+        }
+
+        private bool HandlerModifyLand(IClientAPI sender, Packet Pack)
+        {
+            ModifyLandPacket modify = (ModifyLandPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (modify.AgentData.SessionID != SessionId ||
+                    modify.AgentData.AgentID != AgentId)
+                    return true;
+            }
+
+            #endregion
+            //m_log.Info("[LAND]: LAND:" + modify.ToString());
+            if (modify.ParcelData.Length > 0)
+            {
+                // Note: the ModifyTerrain event handler sends out updated packets before the end of this event.  Therefore,
+                // a simple boolean value should work and perhaps queue up just a few terrain patch packets at the end of the edit.
+                if (OnModifyTerrain != null)
+                {
+                    for (int i = 0; i < modify.ParcelData.Length; i++)
+                    {
+                        ModifyTerrain handlerModifyTerrain = OnModifyTerrain;
+                        if (handlerModifyTerrain != null)
+                        {
+                            handlerModifyTerrain(AgentId, modify.ModifyBlock.Height, modify.ModifyBlock.Seconds,
+                                                 modify.ModifyBlock.BrushSize,
+                                                 modify.ModifyBlock.Action, modify.ParcelData[i].North,
+                                                 modify.ParcelData[i].West, modify.ParcelData[i].South,
+                                                 modify.ParcelData[i].East, AgentId);
+                        }
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandlerRegionHandshakeReply(IClientAPI sender, Packet Pack)
+        {
+            Action<IClientAPI> handlerRegionHandShakeReply = OnRegionHandShakeReply;
+            if (handlerRegionHandShakeReply != null)
+            {
+                handlerRegionHandShakeReply(this);
+            }
+
+            return true;
+        }
+
+        private bool HandlerAgentWearablesRequest(IClientAPI sender, Packet Pack)
+        {
+            GenericCall1 handlerRequestWearables = OnRequestWearables;
+
+            if (handlerRequestWearables != null)
+            {
+                handlerRequestWearables(sender);
+            }
+
+            Action<IClientAPI> handlerRequestAvatarsData = OnRequestAvatarsData;
+
+            if (handlerRequestAvatarsData != null)
+            {
+                handlerRequestAvatarsData(this);
+            }
+
+            return true;
+        }
+
+        private bool HandlerAgentSetAppearance(IClientAPI sender, Packet Pack)
+        {
+            AgentSetAppearancePacket appear = (AgentSetAppearancePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (appear.AgentData.SessionID != SessionId ||
+                    appear.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SetAppearance handlerSetAppearance = OnSetAppearance;
+            if (handlerSetAppearance != null)
+            {
+                // Temporarily protect ourselves from the mantis #951 failure.
+                // However, we could do this for several other handlers where a failure isn't terminal
+                // for the client session anyway, in order to protect ourselves against bad code in plugins
+                Vector3 avSize = appear.AgentData.Size;
+                try
+                {
+                    byte[] visualparams = new byte[appear.VisualParam.Length];
+                    for (int i = 0; i < appear.VisualParam.Length; i++)
+                        visualparams[i] = appear.VisualParam[i].ParamValue;
+                    //var b = appear.WearableData[0];
+
+                    Primitive.TextureEntry te = null;
+                    if (appear.ObjectData.TextureEntry.Length > 1)
+                        te = new Primitive.TextureEntry(appear.ObjectData.TextureEntry, 0, appear.ObjectData.TextureEntry.Length);
+
+                    WearableCacheItem[] cacheitems = new WearableCacheItem[appear.WearableData.Length];
+                    for (int i=0; i<appear.WearableData.Length;i++)
+                        cacheitems[i] = new WearableCacheItem(){
+                            CacheId = appear.WearableData[i].CacheID,
+                            TextureIndex=Convert.ToUInt32(appear.WearableData[i].TextureIndex)
+                        };
+
+
+
+                    handlerSetAppearance(sender, te, visualparams,avSize, cacheitems);
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat(
+                        "[CLIENT VIEW]: AgentSetApperance packet handler threw an exception, {0}",
+                        e);
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandlerAgentIsNowWearing(IClientAPI sender, Packet Pack)
+        {
+            if (OnAvatarNowWearing != null)
+            {
+                AgentIsNowWearingPacket nowWearing = (AgentIsNowWearingPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (nowWearing.AgentData.SessionID != SessionId ||
+                        nowWearing.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                AvatarWearingArgs wearingArgs = new AvatarWearingArgs();
+                for (int i = 0; i < nowWearing.WearableData.Length; i++)
+                {
+                    //m_log.DebugFormat("[XXX]: Wearable type {0} item {1}", nowWearing.WearableData[i].WearableType, nowWearing.WearableData[i].ItemID);
+                    AvatarWearingArgs.Wearable wearable =
+                        new AvatarWearingArgs.Wearable(nowWearing.WearableData[i].ItemID,
+                                                       nowWearing.WearableData[i].WearableType);
+                    wearingArgs.NowWearing.Add(wearable);
+                }
+
+                AvatarNowWearing handlerAvatarNowWearing = OnAvatarNowWearing;
+                if (handlerAvatarNowWearing != null)
+                {
+                    handlerAvatarNowWearing(this, wearingArgs);
+                }
+            }
+            return true;
+        }
+
+        private bool HandlerRezSingleAttachmentFromInv(IClientAPI sender, Packet Pack)
+        {
+            RezSingleAttachmentFromInv handlerRezSingleAttachment = OnRezSingleAttachmentFromInv;
+            if (handlerRezSingleAttachment != null)
+            {
+                RezSingleAttachmentFromInvPacket rez = (RezSingleAttachmentFromInvPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (rez.AgentData.SessionID != SessionId ||
+                        rez.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                handlerRezSingleAttachment(this, rez.ObjectData.ItemID,
+                                           rez.ObjectData.AttachmentPt);
+            }
+
+            return true;
+        }
+
+        private bool HandleRezMultipleAttachmentsFromInv(IClientAPI sender, Packet Pack)
+        {
+            RezMultipleAttachmentsFromInv handlerRezMultipleAttachments = OnRezMultipleAttachmentsFromInv;
+            if (handlerRezMultipleAttachments != null)
+            {
+                List<KeyValuePair<UUID, uint>> rezlist = new List<KeyValuePair<UUID, uint>>();
+                foreach (RezMultipleAttachmentsFromInvPacket.ObjectDataBlock obj in ((RezMultipleAttachmentsFromInvPacket)Pack).ObjectData)
+                    rezlist.Add(new KeyValuePair<UUID, uint>(obj.ItemID, obj.AttachmentPt));
+                handlerRezMultipleAttachments(this, rezlist);
+            }
+
+            return true;
+        }
+
+        private bool HandleDetachAttachmentIntoInv(IClientAPI sender, Packet Pack)
+        {
+            UUIDNameRequest handlerDetachAttachmentIntoInv = OnDetachAttachmentIntoInv;
+            if (handlerDetachAttachmentIntoInv != null)
+            {
+                DetachAttachmentIntoInvPacket detachtoInv = (DetachAttachmentIntoInvPacket)Pack;
+
+                #region Packet Session and User Check
+                // UNSUPPORTED ON THIS PACKET
+                #endregion
+
+                UUID itemID = detachtoInv.ObjectData.ItemID;
+                // UUID ATTACH_agentID = detachtoInv.ObjectData.AgentID;
+
+                handlerDetachAttachmentIntoInv(itemID, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectAttach(IClientAPI sender, Packet Pack)
+        {
+            if (OnObjectAttach != null)
+            {
+                ObjectAttachPacket att = (ObjectAttachPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (att.AgentData.SessionID != SessionId ||
+                        att.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                ObjectAttach handlerObjectAttach = OnObjectAttach;
+
+                if (handlerObjectAttach != null)
+                {
+                    if (att.ObjectData.Length > 0)
+                    {
+                        handlerObjectAttach(this, att.ObjectData[0].ObjectLocalID, att.AgentData.AttachmentPoint, false);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectDetach(IClientAPI sender, Packet Pack)
+        {
+            ObjectDetachPacket dett = (ObjectDetachPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dett.AgentData.SessionID != SessionId ||
+                    dett.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            for (int j = 0; j < dett.ObjectData.Length; j++)
+            {
+                uint obj = dett.ObjectData[j].ObjectLocalID;
+                ObjectDeselect handlerObjectDetach = OnObjectDetach;
+                if (handlerObjectDetach != null)
+                {
+                    handlerObjectDetach(obj, this);
+                }
+
+            }
+            return true;
+        }
+
+        private bool HandleObjectDrop(IClientAPI sender, Packet Pack)
+        {
+            ObjectDropPacket dropp = (ObjectDropPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dropp.AgentData.SessionID != SessionId ||
+                    dropp.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            for (int j = 0; j < dropp.ObjectData.Length; j++)
+            {
+                uint obj = dropp.ObjectData[j].ObjectLocalID;
+                ObjectDrop handlerObjectDrop = OnObjectDrop;
+                if (handlerObjectDrop != null)
+                {
+                    handlerObjectDrop(obj, this);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleSetAlwaysRun(IClientAPI sender, Packet Pack)
+        {
+            SetAlwaysRunPacket run = (SetAlwaysRunPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (run.AgentData.SessionID != SessionId ||
+                    run.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SetAlwaysRun handlerSetAlwaysRun = OnSetAlwaysRun;
+            if (handlerSetAlwaysRun != null)
+                handlerSetAlwaysRun(this, run.AgentData.AlwaysRun);
+
+            return true;
+        }
+
+      private bool HandleCompleteAgentMovement(IClientAPI sender, Packet Pack)
+        {
+            m_log.DebugFormat("[LLClientView] HandleCompleteAgentMovement");
+
+            Action<IClientAPI, bool> handlerCompleteMovementToRegion = OnCompleteMovementToRegion;
+            if (handlerCompleteMovementToRegion != null)
+            {
+                handlerCompleteMovementToRegion(sender, true);
+            }
+            else
+                m_log.Debug("HandleCompleteAgentMovement NULL handler");
+
+            handlerCompleteMovementToRegion = null;
+
+            return true;
+        }
+
+        private bool HandleAgentAnimation(IClientAPI sender, Packet Pack)
+        {
+            AgentAnimationPacket AgentAni = (AgentAnimationPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (AgentAni.AgentData.SessionID != SessionId ||
+                    AgentAni.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+/*
+            StartAnim handlerStartAnim = null;
+            StopAnim handlerStopAnim = null;
+
+            for (int i = 0; i < AgentAni.AnimationList.Length; i++)
+            {
+                if (AgentAni.AnimationList[i].StartAnim)
+                {
+                    handlerStartAnim = OnStartAnim;
+                    if (handlerStartAnim != null)
+                    {
+                        handlerStartAnim(this, AgentAni.AnimationList[i].AnimID);
+                    }
+                }
+                else
+                {
+                    handlerStopAnim = OnStopAnim;
+                    if (handlerStopAnim != null)
+                    {
+                        handlerStopAnim(this, AgentAni.AnimationList[i].AnimID);
+                    }
+                }
+            }
+            return true;
+*/
+            ChangeAnim handlerChangeAnim = null;
+
+            for (int i = 0; i < AgentAni.AnimationList.Length; i++)
+            {
+                handlerChangeAnim = OnChangeAnim;
+                if (handlerChangeAnim != null)
+                {
+                    handlerChangeAnim(AgentAni.AnimationList[i].AnimID, AgentAni.AnimationList[i].StartAnim, false);
+                }
+            }
+
+            handlerChangeAnim = OnChangeAnim;
+            if (handlerChangeAnim != null)
+            {
+                handlerChangeAnim(UUID.Zero, false, true);
+            }
+
+            return true;
+        }
+
+        private bool HandleAgentRequestSit(IClientAPI sender, Packet Pack)
+        {
+            if (OnAgentRequestSit != null)
+            {
+                AgentRequestSitPacket agentRequestSit = (AgentRequestSitPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (agentRequestSit.AgentData.SessionID != SessionId ||
+                        agentRequestSit.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                if (SceneAgent.IsChildAgent)
+                {
+                    SendCantSitBecauseChildAgentResponse();
+                    return true;
+                }
+
+                AgentRequestSit handlerAgentRequestSit = OnAgentRequestSit;
+
+                if (handlerAgentRequestSit != null)
+                    handlerAgentRequestSit(this, agentRequestSit.AgentData.AgentID,
+                                           agentRequestSit.TargetObject.TargetID, agentRequestSit.TargetObject.Offset);
+            }
+            return true;
+        }
+
+        private bool HandleAgentSit(IClientAPI sender, Packet Pack)
+        {
+            if (OnAgentSit != null)
+            {
+                AgentSitPacket agentSit = (AgentSitPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (agentSit.AgentData.SessionID != SessionId ||
+                        agentSit.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                if (SceneAgent.IsChildAgent)
+                {
+                    SendCantSitBecauseChildAgentResponse();
+                    return true;
+                }
+
+                AgentSit handlerAgentSit = OnAgentSit;
+                if (handlerAgentSit != null)
+                {
+                    OnAgentSit(this, agentSit.AgentData.AgentID);
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Used when a child agent gets a sit response which should not be fulfilled.
+        /// </summary>
+        private void SendCantSitBecauseChildAgentResponse()
+        {
+            SendAlertMessage("Try moving closer.  Can't sit on object because it is not in the same region as you.");
+        }
+
+        private bool HandleSoundTrigger(IClientAPI sender, Packet Pack)
+        {
+            SoundTriggerPacket soundTriggerPacket = (SoundTriggerPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                // UNSUPPORTED ON THIS PACKET
+            }
+            #endregion
+
+            SoundTrigger handlerSoundTrigger = OnSoundTrigger;
+            if (handlerSoundTrigger != null)
+            {
+                // UUIDS are sent as zeroes by the client, substitute agent's id
+                handlerSoundTrigger(soundTriggerPacket.SoundData.SoundID, AgentId,
+                    AgentId, AgentId,
+                    soundTriggerPacket.SoundData.Gain, soundTriggerPacket.SoundData.Position,
+                    soundTriggerPacket.SoundData.Handle, 0);
+
+            }
+            return true;
+        }
+
+        private bool HandleAvatarPickerRequest(IClientAPI sender, Packet Pack)
+        {
+            AvatarPickerRequestPacket avRequestQuery = (AvatarPickerRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avRequestQuery.AgentData.SessionID != SessionId ||
+                    avRequestQuery.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            AvatarPickerRequestPacket.AgentDataBlock Requestdata = avRequestQuery.AgentData;
+            AvatarPickerRequestPacket.DataBlock querydata = avRequestQuery.Data;
+            //m_log.Debug("Agent Sends:" + Utils.BytesToString(querydata.Name));
+
+            AvatarPickerRequest handlerAvatarPickerRequest = OnAvatarPickerRequest;
+            if (handlerAvatarPickerRequest != null)
+            {
+                handlerAvatarPickerRequest(this, Requestdata.AgentID, Requestdata.QueryID,
+                                           Utils.BytesToString(querydata.Name));
+            }
+            return true;
+        }
+
+        private bool HandleAgentDataUpdateRequest(IClientAPI sender, Packet Pack)
+        {
+            AgentDataUpdateRequestPacket avRequestDataUpdatePacket = (AgentDataUpdateRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avRequestDataUpdatePacket.AgentData.SessionID != SessionId ||
+                    avRequestDataUpdatePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            FetchInventory handlerAgentDataUpdateRequest = OnAgentDataUpdateRequest;
+
+            if (handlerAgentDataUpdateRequest != null)
+            {
+                handlerAgentDataUpdateRequest(this, avRequestDataUpdatePacket.AgentData.AgentID, avRequestDataUpdatePacket.AgentData.SessionID);
+            }
+
+            return true;
+        }
+
+        private bool HandleUserInfoRequest(IClientAPI sender, Packet Pack)
+        {
+            UserInfoRequest handlerUserInfoRequest = OnUserInfoRequest;
+            if (handlerUserInfoRequest != null)
+            {
+                handlerUserInfoRequest(this);
+            }
+            else
+            {
+                SendUserInfoReply(false, true, "");
+            }
+            return true;
+        }
+
+        private bool HandleUpdateUserInfo(IClientAPI sender, Packet Pack)
+        {
+            UpdateUserInfoPacket updateUserInfo = (UpdateUserInfoPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (updateUserInfo.AgentData.SessionID != SessionId ||
+                    updateUserInfo.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UpdateUserInfo handlerUpdateUserInfo = OnUpdateUserInfo;
+            if (handlerUpdateUserInfo != null)
+            {
+                bool visible = true;
+                string DirectoryVisibility =
+                        Utils.BytesToString(updateUserInfo.UserData.DirectoryVisibility);
+                if (DirectoryVisibility == "hidden")
+                    visible = false;
+
+                handlerUpdateUserInfo(
+                        updateUserInfo.UserData.IMViaEMail,
+                        visible, this);
+            }
+            return true;
+        }
+
+        private bool HandleSetStartLocationRequest(IClientAPI sender, Packet Pack)
+        {
+            SetStartLocationRequestPacket avSetStartLocationRequestPacket = (SetStartLocationRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avSetStartLocationRequestPacket.AgentData.SessionID != SessionId ||
+                    avSetStartLocationRequestPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (avSetStartLocationRequestPacket.AgentData.AgentID == AgentId && avSetStartLocationRequestPacket.AgentData.SessionID == SessionId)
+            {
+                // Linden Client limitation..
+                if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.X == 255.5f
+                    || avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y == 255.5f)
+                {
+                    ScenePresence avatar = null;
+                    if (((Scene)m_scene).TryGetScenePresence(AgentId, out avatar))
+                    {
+                        if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.X == 255.5f)
+                        {
+                            avSetStartLocationRequestPacket.StartLocationData.LocationPos.X = avatar.AbsolutePosition.X;
+                        }
+                        if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y == 255.5f)
+                        {
+                            avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y = avatar.AbsolutePosition.Y;
+                        }
+                    }
+
+                }
+                TeleportLocationRequest handlerSetStartLocationRequest = OnSetStartLocationRequest;
+                if (handlerSetStartLocationRequest != null)
+                {
+                    handlerSetStartLocationRequest(this, 0, avSetStartLocationRequestPacket.StartLocationData.LocationPos,
+                                                   avSetStartLocationRequestPacket.StartLocationData.LocationLookAt,
+                                                   avSetStartLocationRequestPacket.StartLocationData.LocationID);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleAgentThrottle(IClientAPI sender, Packet Pack)
+        {
+            AgentThrottlePacket atpack = (AgentThrottlePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (atpack.AgentData.SessionID != SessionId ||
+                    atpack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            m_udpClient.SetThrottles(atpack.Throttle.Throttles);
+            GenericCall2 handler = OnUpdateThrottles;
+            if (handler != null)
+            {
+                handler();
+            }
+            return true;
+        }
+
+        private bool HandleAgentPause(IClientAPI sender, Packet Pack)
+        {
+            m_udpClient.IsPaused = true;
+            return true;
+        }
+
+        private bool HandleAgentResume(IClientAPI sender, Packet Pack)
+        {
+            m_udpClient.IsPaused = false;
+            SendStartPingCheck(m_udpClient.CurrentPingSequence++);
+            return true;
+        }
+
+        private bool HandleForceScriptControlRelease(IClientAPI sender, Packet Pack)
+        {
+            ForceReleaseControls handlerForceReleaseControls = OnForceReleaseControls;
+            if (handlerForceReleaseControls != null)
+            {
+                handlerForceReleaseControls(this, AgentId);
+            }
+            return true;
+        }
+
+        #endregion Scene/Avatar
+
+        #region Objects/m_sceneObjects
+
+        private bool HandleObjectLink(IClientAPI sender, Packet Pack)
+        {
+            ObjectLinkPacket link = (ObjectLinkPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (link.AgentData.SessionID != SessionId ||
+                    link.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            uint parentprimid = 0;
+            List<uint> childrenprims = new List<uint>();
+            if (link.ObjectData.Length > 1)
+            {
+                parentprimid = link.ObjectData[0].ObjectLocalID;
+
+                for (int i = 1; i < link.ObjectData.Length; i++)
+                {
+                    childrenprims.Add(link.ObjectData[i].ObjectLocalID);
+                }
+            }
+            LinkObjects handlerLinkObjects = OnLinkObjects;
+            if (handlerLinkObjects != null)
+            {
+                handlerLinkObjects(this, parentprimid, childrenprims);
+            }
+            return true;
+        }
+
+        private bool HandleObjectDelink(IClientAPI sender, Packet Pack)
+        {
+            ObjectDelinkPacket delink = (ObjectDelinkPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (delink.AgentData.SessionID != SessionId ||
+                    delink.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            // It appears the prim at index 0 is not always the root prim (for
+            // instance, when one prim of a link set has been edited independently
+            // of the others).  Therefore, we'll pass all the ids onto the delink
+            // method for it to decide which is the root.
+            List<uint> prims = new List<uint>();
+            for (int i = 0; i < delink.ObjectData.Length; i++)
+            {
+                prims.Add(delink.ObjectData[i].ObjectLocalID);
+            }
+            DelinkObjects handlerDelinkObjects = OnDelinkObjects;
+            if (handlerDelinkObjects != null)
+            {
+                handlerDelinkObjects(prims, this);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectAdd(IClientAPI sender, Packet Pack)
+        {
+            if (OnAddPrim != null)
+            {
+                ObjectAddPacket addPacket = (ObjectAddPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (addPacket.AgentData.SessionID != SessionId ||
+                        addPacket.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                PrimitiveBaseShape shape = GetShapeFromAddPacket(addPacket);
+                // m_log.Info("[REZData]: " + addPacket.ToString());
+                //BypassRaycast: 1
+                //RayStart: <69.79469, 158.2652, 98.40343>
+                //RayEnd: <61.97724, 141.995, 92.58341>
+                //RayTargetID: 00000000-0000-0000-0000-000000000000
+
+                //Check to see if adding the prim is allowed; useful for any module wanting to restrict the
+                //object from rezing initially
+
+                AddNewPrim handlerAddPrim = OnAddPrim;
+                if (handlerAddPrim != null)
+                    handlerAddPrim(AgentId, addPacket.AgentData.GroupID, addPacket.ObjectData.RayEnd, addPacket.ObjectData.Rotation, shape, addPacket.ObjectData.BypassRaycast, addPacket.ObjectData.RayStart, addPacket.ObjectData.RayTargetID, addPacket.ObjectData.RayEndIsIntersection);
+            }
+            return true;
+        }
+
+        private bool HandleObjectShape(IClientAPI sender, Packet Pack)
+        {
+            ObjectShapePacket shapePacket = (ObjectShapePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (shapePacket.AgentData.SessionID != SessionId ||
+                    shapePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UpdateShape handlerUpdatePrimShape = null;
+            for (int i = 0; i < shapePacket.ObjectData.Length; i++)
+            {
+                handlerUpdatePrimShape = OnUpdatePrimShape;
+                if (handlerUpdatePrimShape != null)
+                {
+                    UpdateShapeArgs shapeData = new UpdateShapeArgs();
+                    shapeData.ObjectLocalID = shapePacket.ObjectData[i].ObjectLocalID;
+                    shapeData.PathBegin = shapePacket.ObjectData[i].PathBegin;
+                    shapeData.PathCurve = shapePacket.ObjectData[i].PathCurve;
+                    shapeData.PathEnd = shapePacket.ObjectData[i].PathEnd;
+                    shapeData.PathRadiusOffset = shapePacket.ObjectData[i].PathRadiusOffset;
+                    shapeData.PathRevolutions = shapePacket.ObjectData[i].PathRevolutions;
+                    shapeData.PathScaleX = shapePacket.ObjectData[i].PathScaleX;
+                    shapeData.PathScaleY = shapePacket.ObjectData[i].PathScaleY;
+                    shapeData.PathShearX = shapePacket.ObjectData[i].PathShearX;
+                    shapeData.PathShearY = shapePacket.ObjectData[i].PathShearY;
+                    shapeData.PathSkew = shapePacket.ObjectData[i].PathSkew;
+                    shapeData.PathTaperX = shapePacket.ObjectData[i].PathTaperX;
+                    shapeData.PathTaperY = shapePacket.ObjectData[i].PathTaperY;
+                    shapeData.PathTwist = shapePacket.ObjectData[i].PathTwist;
+                    shapeData.PathTwistBegin = shapePacket.ObjectData[i].PathTwistBegin;
+                    shapeData.ProfileBegin = shapePacket.ObjectData[i].ProfileBegin;
+                    shapeData.ProfileCurve = shapePacket.ObjectData[i].ProfileCurve;
+                    shapeData.ProfileEnd = shapePacket.ObjectData[i].ProfileEnd;
+                    shapeData.ProfileHollow = shapePacket.ObjectData[i].ProfileHollow;
+
+                    handlerUpdatePrimShape(m_agentId, shapePacket.ObjectData[i].ObjectLocalID,
+                                           shapeData);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectExtraParams(IClientAPI sender, Packet Pack)
+        {
+            ObjectExtraParamsPacket extraPar = (ObjectExtraParamsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (extraPar.AgentData.SessionID != SessionId ||
+                    extraPar.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectExtraParams handlerUpdateExtraParams = OnUpdateExtraParams;
+            if (handlerUpdateExtraParams != null)
+            {
+                for (int i = 0; i < extraPar.ObjectData.Length; i++)
+                {
+                    handlerUpdateExtraParams(m_agentId, extraPar.ObjectData[i].ObjectLocalID,
+                                             extraPar.ObjectData[i].ParamType,
+                                             extraPar.ObjectData[i].ParamInUse, extraPar.ObjectData[i].ParamData);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectDuplicate(IClientAPI sender, Packet Pack)
+        {
+            ObjectDuplicatePacket dupe = (ObjectDuplicatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dupe.AgentData.SessionID != SessionId ||
+                    dupe.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+//            ObjectDuplicatePacket.AgentDataBlock AgentandGroupData = dupe.AgentData;
+
+            ObjectDuplicate handlerObjectDuplicate = null;
+
+            handlerObjectDuplicate = OnObjectDuplicate;
+            if (handlerObjectDuplicate != null)
+            {
+                for (int i = 0; i < dupe.ObjectData.Length; i++)
+                {
+                    UUID rezGroupID = dupe.AgentData.GroupID;
+                    if(!IsGroupMember(rezGroupID))
+                        rezGroupID = UUID.Zero;
+                    handlerObjectDuplicate(dupe.ObjectData[i].ObjectLocalID, dupe.SharedData.Offset,
+                                           dupe.SharedData.DuplicateFlags, AgentId,
+                                           rezGroupID);
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandleRequestMultipleObjects(IClientAPI sender, Packet Pack)
+        {
+            RequestMultipleObjectsPacket incomingRequest = (RequestMultipleObjectsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (incomingRequest.AgentData.SessionID != SessionId ||
+                    incomingRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectRequest handlerObjectRequest = null;
+
+            for (int i = 0; i < incomingRequest.ObjectData.Length; i++)
+            {
+                handlerObjectRequest = OnObjectRequest;
+                if (handlerObjectRequest != null)
+                {
+                    handlerObjectRequest(incomingRequest.ObjectData[i].ID, this);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectSelect(IClientAPI sender, Packet Pack)
+        {
+            ObjectSelectPacket incomingselect = (ObjectSelectPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (incomingselect.AgentData.SessionID != SessionId ||
+                    incomingselect.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+            List<uint> thisSelection = new List<uint>();
+            ObjectSelect handlerObjectSelect = null;
+            uint objID;
+            handlerObjectSelect = OnObjectSelect;
+            if (handlerObjectSelect != null)
+            {
+                for (int i = 0; i < incomingselect.ObjectData.Length; i++)
+                {
+                    objID = incomingselect.ObjectData[i].ObjectLocalID;
+                    thisSelection.Add(objID);
+                }
+
+                handlerObjectSelect(thisSelection, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectDeselect(IClientAPI sender, Packet Pack)
+        {
+            ObjectDeselectPacket incomingdeselect = (ObjectDeselectPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (incomingdeselect.AgentData.SessionID != SessionId ||
+                    incomingdeselect.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectDeselect handlerObjectDeselect = null;
+            uint objID;
+            for (int i = 0; i < incomingdeselect.ObjectData.Length; i++)
+            {
+                objID = incomingdeselect.ObjectData[i].ObjectLocalID;
+
+                handlerObjectDeselect = OnObjectDeselect;
+                if (handlerObjectDeselect != null)
+                {
+                   OnObjectDeselect(objID, this);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectPosition(IClientAPI sender, Packet Pack)
+        {
+            // DEPRECATED: but till libsecondlife removes it, people will use it
+            ObjectPositionPacket position = (ObjectPositionPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (position.AgentData.SessionID != SessionId ||
+                    position.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+
+            for (int i = 0; i < position.ObjectData.Length; i++)
+            {
+                UpdateVector handlerUpdateVector = OnUpdatePrimGroupPosition;
+                if (handlerUpdateVector != null)
+                    handlerUpdateVector(position.ObjectData[i].ObjectLocalID, position.ObjectData[i].Position, this);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectScale(IClientAPI sender, Packet Pack)
+        {
+            // DEPRECATED: but till libsecondlife removes it, people will use it
+            ObjectScalePacket scale = (ObjectScalePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (scale.AgentData.SessionID != SessionId ||
+                    scale.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            for (int i = 0; i < scale.ObjectData.Length; i++)
+            {
+                UpdateVector handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;
+                if (handlerUpdatePrimGroupScale != null)
+                    handlerUpdatePrimGroupScale(scale.ObjectData[i].ObjectLocalID, scale.ObjectData[i].Scale, this);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectRotation(IClientAPI sender, Packet Pack)
+        {
+            // DEPRECATED: but till libsecondlife removes it, people will use it
+            ObjectRotationPacket rotation = (ObjectRotationPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rotation.AgentData.SessionID != SessionId ||
+                    rotation.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            for (int i = 0; i < rotation.ObjectData.Length; i++)
+            {
+                UpdatePrimRotation handlerUpdatePrimRotation = OnUpdatePrimGroupRotation;
+                if (handlerUpdatePrimRotation != null)
+                    handlerUpdatePrimRotation(rotation.ObjectData[i].ObjectLocalID, rotation.ObjectData[i].Rotation, this);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectFlagUpdate(IClientAPI sender, Packet Pack)
+        {
+            ObjectFlagUpdatePacket flags = (ObjectFlagUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (flags.AgentData.SessionID != SessionId ||
+                    flags.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UpdatePrimFlags handlerUpdatePrimFlags = OnUpdatePrimFlags;
+
+            if (handlerUpdatePrimFlags != null)
+            {
+//                byte[] data = Pack.ToBytes();
+                // 46,47,48 are special positions within the packet
+                // This may change so perhaps we need a better way
+                // of storing this (OMV.FlagUpdatePacket.UsePhysics,etc?)
+                /*
+                                bool UsePhysics = (data[46] != 0) ? true : false;
+                                bool IsTemporary = (data[47] != 0) ? true : false;
+                                bool IsPhantom = (data[48] != 0) ? true : false;
+                                handlerUpdatePrimFlags(flags.AgentData.ObjectLocalID, UsePhysics, IsTemporary, IsPhantom, this);
+                 */
+                bool UsePhysics = flags.AgentData.UsePhysics;
+                bool IsPhantom = flags.AgentData.IsPhantom;
+                bool IsTemporary = flags.AgentData.IsTemporary;
+                ObjectFlagUpdatePacket.ExtraPhysicsBlock[] blocks = flags.ExtraPhysics;
+                ExtraPhysicsData physdata = new ExtraPhysicsData();
+
+                if (blocks == null || blocks.Length == 0)
+                {
+                    physdata.PhysShapeType = PhysShapeType.invalid;
+                }
+                else
+                {
+                    ObjectFlagUpdatePacket.ExtraPhysicsBlock phsblock = blocks[0];
+                    physdata.PhysShapeType = (PhysShapeType)phsblock.PhysicsShapeType;
+                    physdata.Bounce = phsblock.Restitution;
+                    physdata.Density = phsblock.Density;
+                    physdata.Friction = phsblock.Friction;
+                    physdata.GravitationModifier = phsblock.GravityMultiplier;
+                }
+
+                handlerUpdatePrimFlags(flags.AgentData.ObjectLocalID, UsePhysics, IsTemporary, IsPhantom, physdata, this);
+            }
+            return true;
+        }
+
+        Dictionary<uint, uint> objImageSeqs = null;
+        double lastobjImageSeqsMS = 0.0;
+
+        private bool HandleObjectImage(IClientAPI sender, Packet Pack)
+        {
+            ObjectImagePacket imagePack = (ObjectImagePacket)Pack;
+
+            UpdatePrimTexture handlerUpdatePrimTexture = OnUpdatePrimTexture;
+            if (handlerUpdatePrimTexture == null)
+                return true;
+
+            double now = Util.GetTimeStampMS();
+            if(objImageSeqs == null || ( now - lastobjImageSeqsMS > 30000.0))
+            {
+                objImageSeqs = null; // yeah i know superstition...
+                objImageSeqs = new Dictionary<uint, uint>(16);
+            }
+
+            lastobjImageSeqsMS = now;
+            uint seq = Pack.Header.Sequence;
+            uint id;
+            uint lastseq;
+
+            ObjectImagePacket.ObjectDataBlock o;
+            for (int i = 0; i < imagePack.ObjectData.Length; i++)
+            {
+                    o = imagePack.ObjectData[i];
+                    id = o.ObjectLocalID;
+                    if(objImageSeqs.TryGetValue(id, out lastseq))
+                    {
+                        if(seq <= lastseq)
+                            continue;
+                    }
+                    objImageSeqs[id] = seq;
+                    handlerUpdatePrimTexture(id, o.TextureEntry, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectGrab(IClientAPI sender, Packet Pack)
+        {
+            ObjectGrabPacket grab = (ObjectGrabPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (grab.AgentData.SessionID != SessionId ||
+                    grab.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GrabObject handlerGrabObject = OnGrabObject;
+
+            if (handlerGrabObject != null)
+            {
+                List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>();
+                if ((grab.SurfaceInfo != null) && (grab.SurfaceInfo.Length > 0))
+                {
+                    foreach (ObjectGrabPacket.SurfaceInfoBlock surfaceInfo in grab.SurfaceInfo)
+                    {
+                        SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs();
+                        arg.Binormal = surfaceInfo.Binormal;
+                        arg.FaceIndex = surfaceInfo.FaceIndex;
+                        arg.Normal = surfaceInfo.Normal;
+                        arg.Position = surfaceInfo.Position;
+                        arg.STCoord = surfaceInfo.STCoord;
+                        arg.UVCoord = surfaceInfo.UVCoord;
+                        touchArgs.Add(arg);
+                    }
+                }
+                handlerGrabObject(grab.ObjectData.LocalID, grab.ObjectData.GrabOffset, this, touchArgs);
+            }
+            return true;
+        }
+
+        private bool HandleObjectGrabUpdate(IClientAPI sender, Packet Pack)
+        {
+            ObjectGrabUpdatePacket grabUpdate = (ObjectGrabUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (grabUpdate.AgentData.SessionID != SessionId ||
+                    grabUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            MoveObject handlerGrabUpdate = OnGrabUpdate;
+
+            if (handlerGrabUpdate != null)
+            {
+                List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>();
+                if ((grabUpdate.SurfaceInfo != null) && (grabUpdate.SurfaceInfo.Length > 0))
+                {
+                    foreach (ObjectGrabUpdatePacket.SurfaceInfoBlock surfaceInfo in grabUpdate.SurfaceInfo)
+                    {
+                        SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs();
+                        arg.Binormal = surfaceInfo.Binormal;
+                        arg.FaceIndex = surfaceInfo.FaceIndex;
+                        arg.Normal = surfaceInfo.Normal;
+                        arg.Position = surfaceInfo.Position;
+                        arg.STCoord = surfaceInfo.STCoord;
+                        arg.UVCoord = surfaceInfo.UVCoord;
+                        touchArgs.Add(arg);
+                    }
+                }
+
+                handlerGrabUpdate(grabUpdate.ObjectData.ObjectID, grabUpdate.ObjectData.GrabOffsetInitial,
+                                  grabUpdate.ObjectData.GrabPosition, this, touchArgs);
+            }
+            return true;
+        }
+
+        private bool HandleObjectDeGrab(IClientAPI sender, Packet Pack)
+        {
+            ObjectDeGrabPacket deGrab = (ObjectDeGrabPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (deGrab.AgentData.SessionID != SessionId ||
+                    deGrab.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DeGrabObject handlerDeGrabObject = OnDeGrabObject;
+            if (handlerDeGrabObject != null)
+            {
+                List<SurfaceTouchEventArgs> touchArgs = new List<SurfaceTouchEventArgs>();
+                if ((deGrab.SurfaceInfo != null) && (deGrab.SurfaceInfo.Length > 0))
+                {
+                    foreach (ObjectDeGrabPacket.SurfaceInfoBlock surfaceInfo in deGrab.SurfaceInfo)
+                    {
+                        SurfaceTouchEventArgs arg = new SurfaceTouchEventArgs();
+                        arg.Binormal = surfaceInfo.Binormal;
+                        arg.FaceIndex = surfaceInfo.FaceIndex;
+                        arg.Normal = surfaceInfo.Normal;
+                        arg.Position = surfaceInfo.Position;
+                        arg.STCoord = surfaceInfo.STCoord;
+                        arg.UVCoord = surfaceInfo.UVCoord;
+                        touchArgs.Add(arg);
+                    }
+                }
+                handlerDeGrabObject(deGrab.ObjectData.LocalID, this, touchArgs);
+            }
+            return true;
+        }
+
+        private bool HandleObjectSpinStart(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Warn("[CLIENT]: unhandled ObjectSpinStart packet");
+            ObjectSpinStartPacket spinStart = (ObjectSpinStartPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (spinStart.AgentData.SessionID != SessionId ||
+                    spinStart.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SpinStart handlerSpinStart = OnSpinStart;
+            if (handlerSpinStart != null)
+            {
+                handlerSpinStart(spinStart.ObjectData.ObjectID, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectSpinUpdate(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Warn("[CLIENT]: unhandled ObjectSpinUpdate packet");
+            ObjectSpinUpdatePacket spinUpdate = (ObjectSpinUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (spinUpdate.AgentData.SessionID != SessionId ||
+                    spinUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            Vector3 axis;
+            float angle;
+            spinUpdate.ObjectData.Rotation.GetAxisAngle(out axis, out angle);
+            //m_log.Warn("[CLIENT]: ObjectSpinUpdate packet rot axis:" + axis + " angle:" + angle);
+
+            SpinObject handlerSpinUpdate = OnSpinUpdate;
+            if (handlerSpinUpdate != null)
+            {
+                handlerSpinUpdate(spinUpdate.ObjectData.ObjectID, spinUpdate.ObjectData.Rotation, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectSpinStop(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Warn("[CLIENT]: unhandled ObjectSpinStop packet");
+            ObjectSpinStopPacket spinStop = (ObjectSpinStopPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (spinStop.AgentData.SessionID != SessionId ||
+                    spinStop.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SpinStop handlerSpinStop = OnSpinStop;
+            if (handlerSpinStop != null)
+            {
+                handlerSpinStop(spinStop.ObjectData.ObjectID, this);
+            }
+            return true;
+        }
+
+        private bool HandleObjectDescription(IClientAPI sender, Packet Pack)
+        {
+            ObjectDescriptionPacket objDes = (ObjectDescriptionPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objDes.AgentData.SessionID != SessionId ||
+                    objDes.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GenericCall7 handlerObjectDescription = null;
+
+            for (int i = 0; i < objDes.ObjectData.Length; i++)
+            {
+                handlerObjectDescription = OnObjectDescription;
+                if (handlerObjectDescription != null)
+                {
+                    handlerObjectDescription(this, objDes.ObjectData[i].LocalID,
+                                             Util.FieldToString(objDes.ObjectData[i].Description));
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectName(IClientAPI sender, Packet Pack)
+        {
+            ObjectNamePacket objName = (ObjectNamePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objName.AgentData.SessionID != SessionId ||
+                    objName.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GenericCall7 handlerObjectName = null;
+            for (int i = 0; i < objName.ObjectData.Length; i++)
+            {
+                handlerObjectName = OnObjectName;
+                if (handlerObjectName != null)
+                {
+                    handlerObjectName(this, objName.ObjectData[i].LocalID,
+                                      Util.FieldToString(objName.ObjectData[i].Name));
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectPermissions(IClientAPI sender, Packet Pack)
+        {
+            if (OnObjectPermissions != null)
+            {
+                ObjectPermissionsPacket newobjPerms = (ObjectPermissionsPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (newobjPerms.AgentData.SessionID != SessionId ||
+                        newobjPerms.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                UUID AgentID = newobjPerms.AgentData.AgentID;
+                UUID SessionID = newobjPerms.AgentData.SessionID;
+
+                ObjectPermissions handlerObjectPermissions = null;
+
+                for (int i = 0; i < newobjPerms.ObjectData.Length; i++)
+                {
+                    ObjectPermissionsPacket.ObjectDataBlock permChanges = newobjPerms.ObjectData[i];
+
+                    byte field = permChanges.Field;
+                    uint localID = permChanges.ObjectLocalID;
+                    uint mask = permChanges.Mask;
+                    byte set = permChanges.Set;
+
+                    handlerObjectPermissions = OnObjectPermissions;
+
+                    if (handlerObjectPermissions != null)
+                        handlerObjectPermissions(this, AgentID, SessionID, field, localID, mask, set);
+                }
+            }
+
+            // Here's our data,
+            // PermField contains the field the info goes into
+            // PermField determines which mask we're changing
+            //
+            // chmask is the mask of the change
+            // setTF is whether we're adding it or taking it away
+            //
+            // objLocalID is the localID of the object.
+
+            // Unfortunately, we have to pass the event the packet because objData is an array
+            // That means multiple object perms may be updated in a single packet.
+
+            return true;
+        }
+
+        private bool HandleUndo(IClientAPI sender, Packet Pack)
+        {
+            UndoPacket undoitem = (UndoPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (undoitem.AgentData.SessionID != SessionId ||
+                    undoitem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (undoitem.ObjectData.Length > 0)
+            {
+                for (int i = 0; i < undoitem.ObjectData.Length; i++)
+                {
+                    UUID objiD = undoitem.ObjectData[i].ObjectID;
+                    AgentSit handlerOnUndo = OnUndo;
+                    if (handlerOnUndo != null)
+                    {
+                        handlerOnUndo(this, objiD);
+                    }
+
+                }
+            }
+            return true;
+        }
+
+        private bool HandleLandUndo(IClientAPI sender, Packet Pack)
+        {
+            UndoLandPacket undolanditem = (UndoLandPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (undolanditem.AgentData.SessionID != SessionId ||
+                    undolanditem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            LandUndo handlerOnUndo = OnLandUndo;
+            if (handlerOnUndo != null)
+            {
+                handlerOnUndo(this);
+            }
+            return true;
+        }
+
+        private bool HandleRedo(IClientAPI sender, Packet Pack)
+        {
+            RedoPacket redoitem = (RedoPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (redoitem.AgentData.SessionID != SessionId ||
+                    redoitem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (redoitem.ObjectData.Length > 0)
+            {
+                for (int i = 0; i < redoitem.ObjectData.Length; i++)
+                {
+                    UUID objiD = redoitem.ObjectData[i].ObjectID;
+                    AgentSit handlerOnRedo = OnRedo;
+                    if (handlerOnRedo != null)
+                    {
+                        handlerOnRedo(this, objiD);
+                    }
+
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectDuplicateOnRay(IClientAPI sender, Packet Pack)
+        {
+            ObjectDuplicateOnRayPacket dupeOnRay = (ObjectDuplicateOnRayPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dupeOnRay.AgentData.SessionID != SessionId ||
+                    dupeOnRay.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectDuplicateOnRay handlerObjectDuplicateOnRay = null;
+
+            for (int i = 0; i < dupeOnRay.ObjectData.Length; i++)
+            {
+                handlerObjectDuplicateOnRay = OnObjectDuplicateOnRay;
+                if (handlerObjectDuplicateOnRay != null)
+                {
+
+                    UUID rezGroupID = dupeOnRay.AgentData.GroupID;
+                    if(!IsGroupMember(rezGroupID))
+                        rezGroupID = UUID.Zero;
+
+                    handlerObjectDuplicateOnRay(dupeOnRay.ObjectData[i].ObjectLocalID,
+                                    dupeOnRay.AgentData.DuplicateFlags, AgentId, rezGroupID,
+                                    dupeOnRay.AgentData.RayTargetID, dupeOnRay.AgentData.RayEnd,
+                                    dupeOnRay.AgentData.RayStart, dupeOnRay.AgentData.BypassRaycast,
+                                    dupeOnRay.AgentData.RayEndIsIntersection,
+                                    dupeOnRay.AgentData.CopyCenters, dupeOnRay.AgentData.CopyRotates);
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandleRequestObjectPropertiesFamily(IClientAPI sender, Packet Pack)
+        {
+            //This powers the little tooltip that appears when you move your mouse over an object
+            RequestObjectPropertiesFamilyPacket packToolTip = (RequestObjectPropertiesFamilyPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (packToolTip.AgentData.SessionID != SessionId ||
+                    packToolTip.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RequestObjectPropertiesFamilyPacket.ObjectDataBlock packObjBlock = packToolTip.ObjectData;
+
+            RequestObjectPropertiesFamily handlerRequestObjectPropertiesFamily = OnRequestObjectPropertiesFamily;
+
+            if (handlerRequestObjectPropertiesFamily != null)
+            {
+                handlerRequestObjectPropertiesFamily(this, m_agentId, packObjBlock.RequestFlags,
+                                                     packObjBlock.ObjectID);
+            }
+
+            return true;
+        }
+
+        private bool HandleObjectIncludeInSearch(IClientAPI sender, Packet Pack)
+        {
+            //This lets us set objects to appear in search (stuff like DataSnapshot, etc)
+            ObjectIncludeInSearchPacket packInSearch = (ObjectIncludeInSearchPacket)Pack;
+            ObjectIncludeInSearch handlerObjectIncludeInSearch = null;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (packInSearch.AgentData.SessionID != SessionId ||
+                    packInSearch.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            foreach (ObjectIncludeInSearchPacket.ObjectDataBlock objData in packInSearch.ObjectData)
+            {
+                bool inSearch = objData.IncludeInSearch;
+                uint localID = objData.ObjectLocalID;
+
+                handlerObjectIncludeInSearch = OnObjectIncludeInSearch;
+
+                if (handlerObjectIncludeInSearch != null)
+                {
+                    handlerObjectIncludeInSearch(this, inSearch, localID);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleScriptAnswerYes(IClientAPI sender, Packet Pack)
+        {
+            ScriptAnswerYesPacket scriptAnswer = (ScriptAnswerYesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (scriptAnswer.AgentData.SessionID != SessionId ||
+                    scriptAnswer.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ScriptAnswer handlerScriptAnswer = OnScriptAnswer;
+            if (handlerScriptAnswer != null)
+            {
+                handlerScriptAnswer(this, scriptAnswer.Data.TaskID, scriptAnswer.Data.ItemID, scriptAnswer.Data.Questions);
+            }
+            return true;
+        }
+
+        private bool HandleObjectClickAction(IClientAPI sender, Packet Pack)
+        {
+            ObjectClickActionPacket ocpacket = (ObjectClickActionPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (ocpacket.AgentData.SessionID != SessionId ||
+                    ocpacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GenericCall7 handlerObjectClickAction = OnObjectClickAction;
+            if (handlerObjectClickAction != null)
+            {
+                foreach (ObjectClickActionPacket.ObjectDataBlock odata in ocpacket.ObjectData)
+                {
+                    byte action = odata.ClickAction;
+                    uint localID = odata.ObjectLocalID;
+                    handlerObjectClickAction(this, localID, action.ToString());
+                }
+            }
+            return true;
+        }
+
+        private bool HandleObjectMaterial(IClientAPI sender, Packet Pack)
+        {
+            ObjectMaterialPacket ompacket = (ObjectMaterialPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (ompacket.AgentData.SessionID != SessionId ||
+                    ompacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GenericCall7 handlerObjectMaterial = OnObjectMaterial;
+            if (handlerObjectMaterial != null)
+            {
+                foreach (ObjectMaterialPacket.ObjectDataBlock odata in ompacket.ObjectData)
+                {
+                    byte material = odata.Material;
+                    uint localID = odata.ObjectLocalID;
+                    handlerObjectMaterial(this, localID, material.ToString());
+                }
+            }
+            return true;
+        }
+
+        #endregion Objects/m_sceneObjects
+
+        #region Inventory/Asset/Other related packets
+
+        private bool HandleRequestImage(IClientAPI sender, Packet Pack)
+        {
+            RequestImagePacket imageRequest = (RequestImagePacket)Pack;
+            //m_log.Debug("image request: " + Pack.ToString());
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (imageRequest.AgentData.SessionID != SessionId ||
+                    imageRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            //handlerTextureRequest = null;
+            for (int i = 0; i < imageRequest.RequestImage.Length; i++)
+            {
+                TextureRequestArgs args = new TextureRequestArgs();
+
+                RequestImagePacket.RequestImageBlock block = imageRequest.RequestImage[i];
+
+                args.RequestedAssetID = block.Image;
+                args.DiscardLevel = block.DiscardLevel;
+                args.PacketNumber = block.Packet;
+                args.Priority = block.DownloadPriority;
+                args.requestSequence = imageRequest.Header.Sequence;
+
+                // NOTE: This is not a built in part of the LLUDP protocol, but we double the
+                // priority of avatar textures to get avatars rezzing in faster than the
+                // surrounding scene
+                if ((ImageType)block.Type == ImageType.Baked)
+                    args.Priority *= 2.0f;
+
+                ImageManager.EnqueueReq(args);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// This is the entry point for the UDP route by which the client can retrieve asset data.  If the request
+        /// is successful then a TransferInfo packet will be sent back, followed by one or more TransferPackets
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="Pack"></param>
+        /// <returns>This parameter may be ignored since we appear to return true whatever happens</returns>
+        private bool HandleTransferRequest(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Debug("ClientView.ProcessPackets.cs:ProcessInPacket() - Got transfer request");
+
+            TransferRequestPacket transfer = (TransferRequestPacket)Pack;
+            UUID taskID = UUID.Zero;
+            if (transfer.TransferInfo.SourceType == (int)SourceType.SimInventoryItem)
+            {
+                if (!(((Scene)m_scene).Permissions.BypassPermissions()))
+                {
+                    // We're spawning a thread because the permissions check can block this thread
+                    Util.FireAndForget(delegate
+                    {
+                        // This requests the asset if needed
+                        HandleSimInventoryTransferRequestWithPermsCheck(sender, transfer);
+                    }, null, "LLClientView.HandleTransferRequest");
+
+                    return true;
+                }
+            }
+            else if (transfer.TransferInfo.SourceType == (int)SourceType.SimEstate)
+            {
+                //TransferRequestPacket does not include covenant uuid?
+                //get scene covenant uuid
+                taskID = m_scene.RegionInfo.RegionSettings.Covenant;
+            }
+
+            // This is non-blocking
+            MakeAssetRequest(transfer, taskID);
+
+            return true;
+        }
+
+        private void HandleSimInventoryTransferRequestWithPermsCheck(IClientAPI sender, TransferRequestPacket transfer)
+        {
+            UUID taskID = new UUID(transfer.TransferInfo.Params, 48);
+            UUID itemID = new UUID(transfer.TransferInfo.Params, 64);
+            UUID requestID = new UUID(transfer.TransferInfo.Params, 80);
+
+            //m_log.DebugFormat(
+            //    "[CLIENT]: Got request for asset {0} from item {1} in prim {2} by {3}",
+            //    requestID, itemID, taskID, Name);
+
+            //m_log.Debug("Transfer Request: " + transfer.ToString());
+            // Validate inventory transfers
+            // Has to be done here, because AssetCache can't do it
+            //
+            if (taskID != UUID.Zero) // Prim
+            {
+                SceneObjectPart part = ((Scene)m_scene).GetSceneObjectPart(taskID);
+
+                if (part == null)
+                {
+                    m_log.WarnFormat(
+                        "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but prim does not exist",
+                        Name, requestID, itemID, taskID);
+                    return;
+                }
+
+                TaskInventoryItem tii = part.Inventory.GetInventoryItem(itemID);
+                if (tii == null)
+                {
+                    m_log.WarnFormat(
+                        "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but item does not exist",
+                        Name, requestID, itemID, taskID);
+                    return;
+                }
+
+                if (tii.Type == (int)AssetType.LSLText)
+                {
+                    if (!((Scene)m_scene).Permissions.CanEditScript(itemID, taskID, AgentId))
+                        return;
+                }
+                else if (tii.Type == (int)AssetType.Notecard)
+                {
+                    if (!((Scene)m_scene).Permissions.CanEditNotecard(itemID, taskID, AgentId))
+                        return;
+                }
+                else
+                {
+                    // TODO: Change this code to allow items other than notecards and scripts to be successfully
+                    // shared with group.  In fact, this whole block of permissions checking should move to an IPermissionsModule
+                    if (part.OwnerID != AgentId)
+                    {
+                        m_log.WarnFormat(
+                            "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but the prim is owned by {4}",
+                            Name, requestID, itemID, taskID, part.OwnerID);
+                        return;
+                    }
+
+                    if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
+                    {
+                        m_log.WarnFormat(
+                            "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but modify permissions are not set",
+                            Name, requestID, itemID, taskID);
+                        return;
+                    }
+
+                    if (tii.OwnerID != AgentId)
+                    {
+                        m_log.WarnFormat(
+                            "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but the item is owned by {4}",
+                            Name, requestID, itemID, taskID, tii.OwnerID);
+                        return;
+                    }
+
+                    if ((
+                        tii.CurrentPermissions & ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer))
+                            != ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer))
+                    {
+                        m_log.WarnFormat(
+                            "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but item permissions are not modify/copy/transfer",
+                            Name, requestID, itemID, taskID);
+                        return;
+                    }
+
+                    if (tii.AssetID != requestID)
+                    {
+                        m_log.WarnFormat(
+                            "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but this does not match item's asset {4}",
+                            Name, requestID, itemID, taskID, tii.AssetID);
+                        return;
+                    }
+                }
+            }
+            else // Agent
+            {
+                IInventoryAccessModule invAccess = m_scene.RequestModuleInterface<IInventoryAccessModule>();
+                if (invAccess != null)
+                {
+                    if (!invAccess.CanGetAgentInventoryItem(this, itemID, requestID))
+                        return;
+                }
+                else
+                {
+                    return;
+                }
+            }
+
+            // Permissions out of the way, let's request the asset
+            MakeAssetRequest(transfer, taskID);
+
+        }
+
+
+        private bool HandleAssetUploadRequest(IClientAPI sender, Packet Pack)
+        {
+            AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack;
+
+            // m_log.Debug("upload request " + request.ToString());
+            // m_log.Debug("upload request was for assetid: " + request.AssetBlock.TransactionID.Combine(this.SecureSessionId).ToString());
+            UUID temp = UUID.Combine(request.AssetBlock.TransactionID, SecureSessionId);
+
+            UDPAssetUploadRequest handlerAssetUploadRequest = OnAssetUploadRequest;
+
+            if (handlerAssetUploadRequest != null)
+            {
+                handlerAssetUploadRequest(this, temp,
+                                          request.AssetBlock.TransactionID, request.AssetBlock.Type,
+                                          request.AssetBlock.AssetData, request.AssetBlock.StoreLocal,
+                                          request.AssetBlock.Tempfile);
+            }
+            return true;
+        }
+
+        private bool HandleRequestXfer(IClientAPI sender, Packet Pack)
+        {
+            RequestXferPacket xferReq = (RequestXferPacket)Pack;
+
+            RequestXfer handlerRequestXfer = OnRequestXfer;
+
+            if (handlerRequestXfer != null)
+            {
+                handlerRequestXfer(this, xferReq.XferID.ID, Util.FieldToString(xferReq.XferID.Filename));
+            }
+            return true;
+        }
+
+        private bool HandleSendXferPacket(IClientAPI sender, Packet Pack)
+        {
+            SendXferPacketPacket xferRec = (SendXferPacketPacket)Pack;
+
+            XferReceive handlerXferReceive = OnXferReceive;
+            if (handlerXferReceive != null)
+            {
+                handlerXferReceive(this, xferRec.XferID.ID, xferRec.XferID.Packet, xferRec.DataPacket.Data);
+            }
+            return true;
+        }
+
+        private bool HandleConfirmXferPacket(IClientAPI sender, Packet Pack)
+        {
+            ConfirmXferPacketPacket confirmXfer = (ConfirmXferPacketPacket)Pack;
+
+            ConfirmXfer handlerConfirmXfer = OnConfirmXfer;
+            if (handlerConfirmXfer != null)
+            {
+                handlerConfirmXfer(this, confirmXfer.XferID.ID, confirmXfer.XferID.Packet);
+            }
+            return true;
+        }
+
+        private bool HandleAbortXfer(IClientAPI sender, Packet Pack)
+        {
+            AbortXferPacket abortXfer = (AbortXferPacket)Pack;
+            AbortXfer handlerAbortXfer = OnAbortXfer;
+            if (handlerAbortXfer != null)
+            {
+                handlerAbortXfer(this, abortXfer.XferID.ID);
+            }
+
+            return true;
+        }
+
+        private bool HandleCreateInventoryFolder(IClientAPI sender, Packet Pack)
+        {
+            CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (invFolder.AgentData.SessionID != SessionId ||
+                    invFolder.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            CreateInventoryFolder handlerCreateInventoryFolder = OnCreateNewInventoryFolder;
+            if (handlerCreateInventoryFolder != null)
+            {
+                handlerCreateInventoryFolder(this, invFolder.FolderData.FolderID,
+                                             (ushort)invFolder.FolderData.Type,
+                                             Util.FieldToString(invFolder.FolderData.Name),
+                                             invFolder.FolderData.ParentID);
+            }
+            return true;
+        }
+
+        private bool HandleUpdateInventoryFolder(IClientAPI sender, Packet Pack)
+        {
+            if (OnUpdateInventoryFolder != null)
+            {
+                UpdateInventoryFolderPacket invFolderx = (UpdateInventoryFolderPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (invFolderx.AgentData.SessionID != SessionId ||
+                        invFolderx.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                UpdateInventoryFolder handlerUpdateInventoryFolder = null;
+
+                for (int i = 0; i < invFolderx.FolderData.Length; i++)
+                {
+                    handlerUpdateInventoryFolder = OnUpdateInventoryFolder;
+                    if (handlerUpdateInventoryFolder != null)
+                    {
+                        OnUpdateInventoryFolder(this, invFolderx.FolderData[i].FolderID,
+                                                (ushort)invFolderx.FolderData[i].Type,
+                                                Util.FieldToString(invFolderx.FolderData[i].Name),
+                                                invFolderx.FolderData[i].ParentID);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleMoveInventoryFolder(IClientAPI sender, Packet Pack)
+        {
+            if (OnMoveInventoryFolder != null)
+            {
+                MoveInventoryFolderPacket invFoldery = (MoveInventoryFolderPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (invFoldery.AgentData.SessionID != SessionId ||
+                        invFoldery.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                MoveInventoryFolder handlerMoveInventoryFolder = null;
+
+                for (int i = 0; i < invFoldery.InventoryData.Length; i++)
+                {
+                    handlerMoveInventoryFolder = OnMoveInventoryFolder;
+                    if (handlerMoveInventoryFolder != null)
+                    {
+                        OnMoveInventoryFolder(this, invFoldery.InventoryData[i].FolderID,
+                                              invFoldery.InventoryData[i].ParentID);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleCreateInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (createItem.AgentData.SessionID != SessionId ||
+                    createItem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            CreateNewInventoryItem handlerCreateNewInventoryItem = OnCreateNewInventoryItem;
+            if (handlerCreateNewInventoryItem != null)
+            {
+                handlerCreateNewInventoryItem(this, createItem.InventoryBlock.TransactionID,
+                                              createItem.InventoryBlock.FolderID,
+                                              createItem.InventoryBlock.CallbackID,
+                                              Util.FieldToString(createItem.InventoryBlock.Description),
+                                              Util.FieldToString(createItem.InventoryBlock.Name),
+                                              createItem.InventoryBlock.InvType,
+                                              createItem.InventoryBlock.Type,
+                                              createItem.InventoryBlock.WearableType,
+                                              createItem.InventoryBlock.NextOwnerMask,
+                                              Util.UnixTimeSinceEpoch());
+            }
+            return true;
+        }
+
+        private bool HandleLinkInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            LinkInventoryItemPacket createLink = (LinkInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (createLink.AgentData.SessionID != SessionId ||
+                    createLink.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            LinkInventoryItem linkInventoryItem = OnLinkInventoryItem;
+
+            if (linkInventoryItem != null)
+            {
+                linkInventoryItem(
+                    this,
+                    createLink.InventoryBlock.TransactionID,
+                    createLink.InventoryBlock.FolderID,
+                    createLink.InventoryBlock.CallbackID,
+                    Util.FieldToString(createLink.InventoryBlock.Description),
+                    Util.FieldToString(createLink.InventoryBlock.Name),
+                    createLink.InventoryBlock.InvType,
+                    createLink.InventoryBlock.Type,
+                    createLink.InventoryBlock.OldItemID);
+            }
+
+            return true;
+        }
+
+        private bool HandleFetchInventory(IClientAPI sender, Packet Pack)
+        {
+            if (OnFetchInventory != null)
+            {
+                FetchInventoryPacket FetchInventoryx = (FetchInventoryPacket)Pack;
+
+                #region Packet Session and User Check
+                if (m_checkPackets)
+                {
+                    if (FetchInventoryx.AgentData.SessionID != SessionId ||
+                        FetchInventoryx.AgentData.AgentID != AgentId)
+                        return true;
+                }
+                #endregion
+
+                FetchInventory handlerFetchInventory = null;
+
+                for (int i = 0; i < FetchInventoryx.InventoryData.Length; i++)
+                {
+                    handlerFetchInventory = OnFetchInventory;
+
+                    if (handlerFetchInventory != null)
+                    {
+                        OnFetchInventory(this, FetchInventoryx.InventoryData[i].ItemID,
+                                         FetchInventoryx.InventoryData[i].OwnerID);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleFetchInventoryDescendents(IClientAPI sender, Packet Pack)
+        {
+            FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (Fetch.AgentData.SessionID != SessionId ||
+                    Fetch.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            FetchInventoryDescendents handlerFetchInventoryDescendents = OnFetchInventoryDescendents;
+            if (handlerFetchInventoryDescendents != null)
+            {
+                handlerFetchInventoryDescendents(this, Fetch.InventoryData.FolderID, Fetch.InventoryData.OwnerID,
+                                                 Fetch.InventoryData.FetchFolders, Fetch.InventoryData.FetchItems,
+                                                 Fetch.InventoryData.SortOrder);
+            }
+            return true;
+        }
+
+        private bool HandlePurgeInventoryDescendents(IClientAPI sender, Packet Pack)
+        {
+            PurgeInventoryDescendentsPacket Purge = (PurgeInventoryDescendentsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (Purge.AgentData.SessionID != SessionId ||
+                    Purge.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            PurgeInventoryDescendents handlerPurgeInventoryDescendents = OnPurgeInventoryDescendents;
+            if (handlerPurgeInventoryDescendents != null)
+            {
+                handlerPurgeInventoryDescendents(this, Purge.InventoryData.FolderID);
+            }
+            return true;
+        }
+
+        private bool HandleUpdateInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            UpdateInventoryItemPacket inventoryItemUpdate = (UpdateInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (inventoryItemUpdate.AgentData.SessionID != SessionId ||
+                    inventoryItemUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnUpdateInventoryItem != null)
+            {
+                UpdateInventoryItem handlerUpdateInventoryItem = null;
+                for (int i = 0; i < inventoryItemUpdate.InventoryData.Length; i++)
+                {
+                    handlerUpdateInventoryItem = OnUpdateInventoryItem;
+
+                    if (handlerUpdateInventoryItem != null)
+                    {
+                        InventoryItemBase itemUpd = new InventoryItemBase();
+                        itemUpd.ID = inventoryItemUpdate.InventoryData[i].ItemID;
+                        itemUpd.Name = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Name);
+                        itemUpd.Description = Util.FieldToString(inventoryItemUpdate.InventoryData[i].Description);
+                        itemUpd.GroupID = inventoryItemUpdate.InventoryData[i].GroupID;
+                        itemUpd.GroupOwned = inventoryItemUpdate.InventoryData[i].GroupOwned;
+                        itemUpd.GroupPermissions = inventoryItemUpdate.InventoryData[i].GroupMask;
+                        itemUpd.NextPermissions = inventoryItemUpdate.InventoryData[i].NextOwnerMask;
+                        itemUpd.EveryOnePermissions = inventoryItemUpdate.InventoryData[i].EveryoneMask;
+                        itemUpd.CreationDate = inventoryItemUpdate.InventoryData[i].CreationDate;
+                        itemUpd.Folder = inventoryItemUpdate.InventoryData[i].FolderID;
+                        itemUpd.InvType = inventoryItemUpdate.InventoryData[i].InvType;
+                        itemUpd.SalePrice = inventoryItemUpdate.InventoryData[i].SalePrice;
+                        itemUpd.SaleType = inventoryItemUpdate.InventoryData[i].SaleType;
+                        itemUpd.Flags = inventoryItemUpdate.InventoryData[i].Flags;
+
+                        OnUpdateInventoryItem(this, inventoryItemUpdate.InventoryData[i].TransactionID,
+                                              inventoryItemUpdate.InventoryData[i].ItemID,
+                                              itemUpd);
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleCopyInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            CopyInventoryItemPacket copyitem = (CopyInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (copyitem.AgentData.SessionID != SessionId ||
+                    copyitem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            CopyInventoryItem handlerCopyInventoryItem = null;
+            if (OnCopyInventoryItem != null)
+            {
+                foreach (CopyInventoryItemPacket.InventoryDataBlock datablock in copyitem.InventoryData)
+                {
+                    handlerCopyInventoryItem = OnCopyInventoryItem;
+                    if (handlerCopyInventoryItem != null)
+                    {
+                        handlerCopyInventoryItem(this, datablock.CallbackID, datablock.OldAgentID,
+                                                 datablock.OldItemID, datablock.NewFolderID,
+                                                 Util.FieldToString(datablock.NewName));
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool HandleMoveInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            MoveInventoryItemPacket moveitem = (MoveInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (moveitem.AgentData.SessionID != SessionId ||
+                    moveitem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnMoveInventoryItem != null)
+            {
+                MoveInventoryItem handlerMoveInventoryItem = null;
+                InventoryItemBase itm = null;
+                List<InventoryItemBase> items = new List<InventoryItemBase>();
+                foreach (MoveInventoryItemPacket.InventoryDataBlock datablock in moveitem.InventoryData)
+                {
+                    itm = new InventoryItemBase(datablock.ItemID, AgentId);
+                    itm.Folder = datablock.FolderID;
+                    itm.Name = Util.FieldToString(datablock.NewName);
+                    // weird, comes out as empty string
+                    //m_log.DebugFormat("[XXX] new name: {0}", itm.Name);
+                    items.Add(itm);
+                }
+                handlerMoveInventoryItem = OnMoveInventoryItem;
+                if (handlerMoveInventoryItem != null)
+                {
+                    handlerMoveInventoryItem(this, items);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleRemoveInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            RemoveInventoryItemPacket removeItem = (RemoveInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (removeItem.AgentData.SessionID != SessionId ||
+                    removeItem.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnRemoveInventoryItem != null)
+            {
+                RemoveInventoryItem handlerRemoveInventoryItem = null;
+                List<UUID> uuids = new List<UUID>();
+                foreach (RemoveInventoryItemPacket.InventoryDataBlock datablock in removeItem.InventoryData)
+                {
+                    uuids.Add(datablock.ItemID);
+                }
+                handlerRemoveInventoryItem = OnRemoveInventoryItem;
+                if (handlerRemoveInventoryItem != null)
+                {
+                    handlerRemoveInventoryItem(this, uuids);
+                }
+
+            }
+            return true;
+        }
+
+        private bool HandleRemoveInventoryFolder(IClientAPI sender, Packet Pack)
+        {
+            RemoveInventoryFolderPacket removeFolder = (RemoveInventoryFolderPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (removeFolder.AgentData.SessionID != SessionId ||
+                    removeFolder.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnRemoveInventoryFolder != null)
+            {
+                RemoveInventoryFolder handlerRemoveInventoryFolder = null;
+                List<UUID> uuids = new List<UUID>();
+                foreach (RemoveInventoryFolderPacket.FolderDataBlock datablock in removeFolder.FolderData)
+                {
+                    uuids.Add(datablock.FolderID);
+                }
+                handlerRemoveInventoryFolder = OnRemoveInventoryFolder;
+                if (handlerRemoveInventoryFolder != null)
+                {
+                    handlerRemoveInventoryFolder(this, uuids);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleRemoveInventoryObjects(IClientAPI sender, Packet Pack)
+        {
+            RemoveInventoryObjectsPacket removeObject = (RemoveInventoryObjectsPacket)Pack;
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (removeObject.AgentData.SessionID != SessionId ||
+                    removeObject.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+            if (OnRemoveInventoryFolder != null)
+            {
+                RemoveInventoryFolder handlerRemoveInventoryFolder = null;
+                List<UUID> uuids = new List<UUID>();
+                foreach (RemoveInventoryObjectsPacket.FolderDataBlock datablock in removeObject.FolderData)
+                {
+                    uuids.Add(datablock.FolderID);
+                }
+                handlerRemoveInventoryFolder = OnRemoveInventoryFolder;
+                if (handlerRemoveInventoryFolder != null)
+                {
+                    handlerRemoveInventoryFolder(this, uuids);
+                }
+            }
+
+            if (OnRemoveInventoryItem != null)
+            {
+                RemoveInventoryItem handlerRemoveInventoryItem = null;
+                List<UUID> uuids = new List<UUID>();
+                foreach (RemoveInventoryObjectsPacket.ItemDataBlock datablock in removeObject.ItemData)
+                {
+                    uuids.Add(datablock.ItemID);
+                }
+                handlerRemoveInventoryItem = OnRemoveInventoryItem;
+                if (handlerRemoveInventoryItem != null)
+                {
+                    handlerRemoveInventoryItem(this, uuids);
+                }
+            }
+            return true;
+        }
+
+        private bool HandleRequestTaskInventory(IClientAPI sender, Packet Pack)
+        {
+            RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (requesttask.AgentData.SessionID != SessionId ||
+                    requesttask.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RequestTaskInventory handlerRequestTaskInventory = OnRequestTaskInventory;
+            if (handlerRequestTaskInventory != null)
+            {
+                handlerRequestTaskInventory(this, requesttask.InventoryData.LocalID);
+            }
+            return true;
+        }
+
+        private bool HandleUpdateTaskInventory(IClientAPI sender, Packet Pack)
+        {
+            UpdateTaskInventoryPacket updatetask = (UpdateTaskInventoryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (updatetask.AgentData.SessionID != SessionId ||
+                    updatetask.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnUpdateTaskInventory != null)
+            {
+                if (updatetask.UpdateData.Key == 0)
+                {
+                    UpdateTaskInventory handlerUpdateTaskInventory = OnUpdateTaskInventory;
+                    if (handlerUpdateTaskInventory != null)
+                    {
+                        TaskInventoryItem newTaskItem = new TaskInventoryItem();
+                        newTaskItem.ItemID = updatetask.InventoryData.ItemID;
+                        newTaskItem.ParentID = updatetask.InventoryData.FolderID;
+                        newTaskItem.CreatorID = updatetask.InventoryData.CreatorID;
+                        newTaskItem.OwnerID = updatetask.InventoryData.OwnerID;
+                        newTaskItem.GroupID = updatetask.InventoryData.GroupID;
+                        newTaskItem.BasePermissions = updatetask.InventoryData.BaseMask;
+                        newTaskItem.CurrentPermissions = updatetask.InventoryData.OwnerMask;
+                        newTaskItem.GroupPermissions = updatetask.InventoryData.GroupMask;
+                        newTaskItem.EveryonePermissions = updatetask.InventoryData.EveryoneMask;
+                        newTaskItem.NextPermissions = updatetask.InventoryData.NextOwnerMask;
+
+                        // Unused?  Clicking share with group sets GroupPermissions instead, so perhaps this is something
+                        // different
+                        //newTaskItem.GroupOwned=updatetask.InventoryData.GroupOwned;
+                        newTaskItem.Type = updatetask.InventoryData.Type;
+                        newTaskItem.InvType = updatetask.InventoryData.InvType;
+                        newTaskItem.Flags = updatetask.InventoryData.Flags;
+                        //newTaskItem.SaleType=updatetask.InventoryData.SaleType;
+                        //newTaskItem.SalePrice=updatetask.InventoryData.SalePrice;
+                        newTaskItem.Name = Util.FieldToString(updatetask.InventoryData.Name);
+                        newTaskItem.Description = Util.FieldToString(updatetask.InventoryData.Description);
+                        newTaskItem.CreationDate = (uint)updatetask.InventoryData.CreationDate;
+                        handlerUpdateTaskInventory(this, updatetask.InventoryData.TransactionID,
+                                                   newTaskItem, updatetask.UpdateData.LocalID);
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        private bool HandleRemoveTaskInventory(IClientAPI sender, Packet Pack)
+        {
+            RemoveTaskInventoryPacket removeTask = (RemoveTaskInventoryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (removeTask.AgentData.SessionID != SessionId ||
+                    removeTask.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RemoveTaskInventory handlerRemoveTaskItem = OnRemoveTaskItem;
+
+            if (handlerRemoveTaskItem != null)
+            {
+                handlerRemoveTaskItem(this, removeTask.InventoryData.ItemID, removeTask.InventoryData.LocalID);
+            }
+
+            return true;
+        }
+
+        private bool HandleMoveTaskInventory(IClientAPI sender, Packet Pack)
+        {
+            MoveTaskInventoryPacket moveTaskInventoryPacket = (MoveTaskInventoryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (moveTaskInventoryPacket.AgentData.SessionID != SessionId ||
+                    moveTaskInventoryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            MoveTaskInventory handlerMoveTaskItem = OnMoveTaskItem;
+
+            if (handlerMoveTaskItem != null)
+            {
+                handlerMoveTaskItem(
+                    this, moveTaskInventoryPacket.AgentData.FolderID,
+                    moveTaskInventoryPacket.InventoryData.LocalID,
+                    moveTaskInventoryPacket.InventoryData.ItemID);
+            }
+
+            return true;
+        }
+
+        private bool HandleRezScript(IClientAPI sender, Packet Pack)
+        {
+            //m_log.Debug(Pack.ToString());
+            RezScriptPacket rezScriptx = (RezScriptPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rezScriptx.AgentData.SessionID != SessionId ||
+                    rezScriptx.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RezScript handlerRezScript = OnRezScript;
+            InventoryItemBase item = new InventoryItemBase();
+            item.ID = rezScriptx.InventoryBlock.ItemID;
+            item.Folder = rezScriptx.InventoryBlock.FolderID;
+            item.CreatorId = rezScriptx.InventoryBlock.CreatorID.ToString();
+            item.Owner = rezScriptx.InventoryBlock.OwnerID;
+            item.BasePermissions = rezScriptx.InventoryBlock.BaseMask;
+            item.CurrentPermissions = rezScriptx.InventoryBlock.OwnerMask;
+            item.EveryOnePermissions = rezScriptx.InventoryBlock.EveryoneMask;
+            item.NextPermissions = rezScriptx.InventoryBlock.NextOwnerMask;
+            item.GroupPermissions = rezScriptx.InventoryBlock.GroupMask;
+            item.GroupOwned = rezScriptx.InventoryBlock.GroupOwned;
+            item.GroupID = rezScriptx.InventoryBlock.GroupID;
+            item.AssetType = rezScriptx.InventoryBlock.Type;
+            item.InvType = rezScriptx.InventoryBlock.InvType;
+            item.Flags = rezScriptx.InventoryBlock.Flags;
+            item.SaleType = rezScriptx.InventoryBlock.SaleType;
+            item.SalePrice = rezScriptx.InventoryBlock.SalePrice;
+            item.Name = Util.FieldToString(rezScriptx.InventoryBlock.Name);
+            item.Description = Util.FieldToString(rezScriptx.InventoryBlock.Description);
+            item.CreationDate = rezScriptx.InventoryBlock.CreationDate;
+
+            if (handlerRezScript != null)
+            {
+                handlerRezScript(this, item, rezScriptx.InventoryBlock.TransactionID, rezScriptx.UpdateBlock.ObjectLocalID);
+            }
+            return true;
+        }
+
+        private bool HandleMapLayerRequest(IClientAPI sender, Packet Pack)
+        {
+            RequestMapLayer();
+            return true;
+        }
+
+        private bool HandleMapBlockRequest(IClientAPI sender, Packet Pack)
+        {
+            MapBlockRequestPacket MapRequest = (MapBlockRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (MapRequest.AgentData.SessionID != SessionId ||
+                    MapRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RequestMapBlocks handlerRequestMapBlocks = OnRequestMapBlocks;
+            if (handlerRequestMapBlocks != null)
+            {
+                handlerRequestMapBlocks(this, MapRequest.PositionData.MinX, MapRequest.PositionData.MinY,
+                                        MapRequest.PositionData.MaxX, MapRequest.PositionData.MaxY, MapRequest.AgentData.Flags);
+            }
+            return true;
+        }
+
+        private bool HandleMapNameRequest(IClientAPI sender, Packet Pack)
+        {
+            MapNameRequestPacket map = (MapNameRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (map.AgentData.SessionID != SessionId ||
+                    map.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+            string mapName = (map.NameData.Name.Length == 0) ? m_scene.RegionInfo.RegionName :
+                Util.UTF8.GetString(map.NameData.Name, 0, map.NameData.Name.Length - 1);
+            RequestMapName handlerMapNameRequest = OnMapNameRequest;
+            if (handlerMapNameRequest != null)
+            {
+                handlerMapNameRequest(this, mapName, map.AgentData.Flags);
+            }
+            return true;
+        }
+
+        private bool HandleTeleportLandmarkRequest(IClientAPI sender, Packet Pack)
+        {
+            TeleportLandmarkRequestPacket tpReq = (TeleportLandmarkRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (tpReq.Info.SessionID != SessionId ||
+                    tpReq.Info.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UUID lmid = tpReq.Info.LandmarkID;
+            AssetLandmark lm;
+            if (lmid != UUID.Zero)
+            {
+
+                //AssetBase lma = m_assetCache.GetAsset(lmid, false);
+                AssetBase lma = m_assetService.Get(lmid.ToString());
+
+                if (lma == null)
+                {
+                    // Failed to find landmark
+
+                    // Let's try to search in the user's home asset server
+                    lma = FindAssetInUserAssetServer(lmid.ToString());
+
+                    if (lma == null)
+                    {
+                        // Really doesn't exist
+                        TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
+                        tpCancel.Info.SessionID = tpReq.Info.SessionID;
+                        tpCancel.Info.AgentID = tpReq.Info.AgentID;
+                        OutPacket(tpCancel, ThrottleOutPacketType.Task);
+                    }
+                }
+
+                try
+                {
+                    lm = new AssetLandmark(lma);
+                }
+                catch (NullReferenceException)
+                {
+                    // asset not found generates null ref inside the assetlandmark constructor.
+                    TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
+                    tpCancel.Info.SessionID = tpReq.Info.SessionID;
+                    tpCancel.Info.AgentID = tpReq.Info.AgentID;
+                    OutPacket(tpCancel, ThrottleOutPacketType.Task);
+                    return true;
+                }
+            }
+            else
+            {
+                // Teleport home request
+                UUIDNameRequest handlerTeleportHomeRequest = OnTeleportHomeRequest;
+                if (handlerTeleportHomeRequest != null)
+                {
+                    handlerTeleportHomeRequest(AgentId, this);
+                }
+                return true;
+            }
+
+            TeleportLandmarkRequest handlerTeleportLandmarkRequest = OnTeleportLandmarkRequest;
+            if (handlerTeleportLandmarkRequest != null)
+            {
+                handlerTeleportLandmarkRequest(this, lm);
+            }
+            else
+            {
+                //no event handler so cancel request
+                TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
+                tpCancel.Info.AgentID = tpReq.Info.AgentID;
+                tpCancel.Info.SessionID = tpReq.Info.SessionID;
+                OutPacket(tpCancel, ThrottleOutPacketType.Task);
+
+            }
+            return true;
+        }
+
+        private bool HandleTeleportCancel(IClientAPI sender, Packet Pack)
+        {
+            TeleportCancel handlerTeleportCancel = OnTeleportCancel;
+            if (handlerTeleportCancel != null)
+            {
+                handlerTeleportCancel(this);
+            }
+            return true;
+        }
+
+        private AssetBase FindAssetInUserAssetServer(string id)
+        {
+            AgentCircuitData aCircuit = ((Scene)Scene).AuthenticateHandler.GetAgentCircuitData(CircuitCode);
+            if (aCircuit != null && aCircuit.ServiceURLs != null && aCircuit.ServiceURLs.ContainsKey("AssetServerURI"))
+            {
+                string assetServer = aCircuit.ServiceURLs["AssetServerURI"].ToString();
+                if (!string.IsNullOrEmpty(assetServer))
+                    return ((Scene)Scene).AssetService.Get(assetServer + "/" + id);
+            }
+
+            return null;
+        }
+
+        private bool HandleTeleportLocationRequest(IClientAPI sender, Packet Pack)
+        {
+            TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack;
+            // m_log.Debug(tpLocReq.ToString());
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (tpLocReq.AgentData.SessionID != SessionId ||
+                    tpLocReq.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            TeleportLocationRequest handlerTeleportLocationRequest = OnTeleportLocationRequest;
+            if (handlerTeleportLocationRequest != null)
+            {
+                // Adjust teleport location to base of a larger region if requested to teleport to a sub-region
+                uint locX, locY;
+                Util.RegionHandleToWorldLoc(tpLocReq.Info.RegionHandle, out locX, out locY);
+                if ((locX >= m_scene.RegionInfo.WorldLocX)
+                            && (locX < (m_scene.RegionInfo.WorldLocX + m_scene.RegionInfo.RegionSizeX))
+                            && (locY >= m_scene.RegionInfo.WorldLocY)
+                            && (locY < (m_scene.RegionInfo.WorldLocY + m_scene.RegionInfo.RegionSizeY)))
+                {
+                    tpLocReq.Info.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                    tpLocReq.Info.Position.X += locX - m_scene.RegionInfo.WorldLocX;
+                    tpLocReq.Info.Position.Y += locY - m_scene.RegionInfo.WorldLocY;
+                }
+
+                handlerTeleportLocationRequest(this, tpLocReq.Info.RegionHandle, tpLocReq.Info.Position,
+                                               tpLocReq.Info.LookAt, 16);
+            }
+            else
+            {
+                //no event handler so cancel request
+                TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
+                tpCancel.Info.SessionID = tpLocReq.AgentData.SessionID;
+                tpCancel.Info.AgentID = tpLocReq.AgentData.AgentID;
+                OutPacket(tpCancel, ThrottleOutPacketType.Task);
+            }
+            return true;
+        }
+
+        #endregion Inventory/Asset/Other related packets
+
+        private bool HandleUUIDNameRequest(IClientAPI sender, Packet Pack)
+        {
+            ScenePresence sp = (ScenePresence)SceneAgent;
+            if(sp == null || sp.IsDeleted || (sp.IsInTransit && !sp.IsInLocalTransit))
+                return true;
+
+            UUIDNameRequestPacket incoming = (UUIDNameRequestPacket)Pack;
+
+            foreach (UUIDNameRequestPacket.UUIDNameBlockBlock UUIDBlock in incoming.UUIDNameBlock)
+            {
+                UUIDNameRequest handlerNameRequest = OnNameFromUUIDRequest;
+                if (handlerNameRequest != null)
+                {
+                    handlerNameRequest(UUIDBlock.ID, this);
+                }
+            }
+            return true;
+        }
+
+        #region Parcel related packets
+
+        private bool HandleRegionHandleRequest(IClientAPI sender, Packet Pack)
+        {
+            RegionHandleRequest handlerRegionHandleRequest = OnRegionHandleRequest;
+
+            if (handlerRegionHandleRequest != null)
+            {
+                RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack;
+                handlerRegionHandleRequest(this, rhrPack.RequestBlock.RegionID);
+            }
+
+            return true;
+        }
+
+        private bool HandleParcelInfoRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelInfoRequestPacket pirPack = (ParcelInfoRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (pirPack.AgentData.SessionID != SessionId ||
+                    pirPack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelInfoRequest handlerParcelInfoRequest = OnParcelInfoRequest;
+            if (handlerParcelInfoRequest != null)
+            {
+                handlerParcelInfoRequest(this, pirPack.Data.ParcelID);
+            }
+            return true;
+        }
+
+        private bool HandleParcelAccessListRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelAccessListRequestPacket requestPacket = (ParcelAccessListRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (requestPacket.AgentData.SessionID != SessionId ||
+                    requestPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelAccessListRequest handlerParcelAccessListRequest = OnParcelAccessListRequest;
+
+            if (handlerParcelAccessListRequest != null)
+            {
+                handlerParcelAccessListRequest(requestPacket.AgentData.AgentID, requestPacket.AgentData.SessionID,
+                                               requestPacket.Data.Flags, requestPacket.Data.SequenceID,
+                                               requestPacket.Data.LocalID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelAccessListUpdate(IClientAPI sender, Packet Pack)
+        {
+            ParcelAccessListUpdatePacket updatePacket = (ParcelAccessListUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (updatePacket.AgentData.SessionID != SessionId ||
+                    updatePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            List<LandAccessEntry> entries = new List<LandAccessEntry>();
+            foreach (ParcelAccessListUpdatePacket.ListBlock block in updatePacket.List)
+            {
+                LandAccessEntry entry = new LandAccessEntry();
+                entry.AgentID = block.ID;
+                entry.Flags = (AccessList)block.Flags;
+                entry.Expires = block.Time;
+                entries.Add(entry);
+            }
+
+            ParcelAccessListUpdateRequest handlerParcelAccessListUpdateRequest = OnParcelAccessListUpdateRequest;
+            if (handlerParcelAccessListUpdateRequest != null)
+            {
+                handlerParcelAccessListUpdateRequest(updatePacket.AgentData.AgentID,
+                                                     updatePacket.Data.Flags,
+                                                     updatePacket.Data.LocalID,
+                                                     updatePacket.Data.TransactionID,
+                                                     updatePacket.Data.SequenceID,
+                                                     updatePacket.Data.Sections,
+                                                     entries, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelPropertiesRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelPropertiesRequestPacket propertiesRequest = (ParcelPropertiesRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (propertiesRequest.AgentData.SessionID != SessionId ||
+                    propertiesRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelPropertiesRequest handlerParcelPropertiesRequest = OnParcelPropertiesRequest;
+            if (handlerParcelPropertiesRequest != null)
+            {
+                handlerParcelPropertiesRequest((int)Math.Round(propertiesRequest.ParcelData.West),
+                                               (int)Math.Round(propertiesRequest.ParcelData.South),
+                                               (int)Math.Round(propertiesRequest.ParcelData.East),
+                                               (int)Math.Round(propertiesRequest.ParcelData.North),
+                                               propertiesRequest.ParcelData.SequenceID,
+                                               propertiesRequest.ParcelData.SnapSelection, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelDivide(IClientAPI sender, Packet Pack)
+        {
+            ParcelDividePacket landDivide = (ParcelDividePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (landDivide.AgentData.SessionID != SessionId ||
+                    landDivide.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelDivideRequest handlerParcelDivideRequest = OnParcelDivideRequest;
+            if (handlerParcelDivideRequest != null)
+            {
+                handlerParcelDivideRequest((int)Math.Round(landDivide.ParcelData.West),
+                                           (int)Math.Round(landDivide.ParcelData.South),
+                                           (int)Math.Round(landDivide.ParcelData.East),
+                                           (int)Math.Round(landDivide.ParcelData.North), this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelJoin(IClientAPI sender, Packet Pack)
+        {
+            ParcelJoinPacket landJoin = (ParcelJoinPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (landJoin.AgentData.SessionID != SessionId ||
+                    landJoin.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelJoinRequest handlerParcelJoinRequest = OnParcelJoinRequest;
+
+            if (handlerParcelJoinRequest != null)
+            {
+                handlerParcelJoinRequest((int)Math.Round(landJoin.ParcelData.West),
+                                         (int)Math.Round(landJoin.ParcelData.South),
+                                         (int)Math.Round(landJoin.ParcelData.East),
+                                         (int)Math.Round(landJoin.ParcelData.North), this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelPropertiesUpdate(IClientAPI sender, Packet Pack)
+        {
+            ParcelPropertiesUpdatePacket parcelPropertiesPacket = (ParcelPropertiesUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (parcelPropertiesPacket.AgentData.SessionID != SessionId ||
+                    parcelPropertiesPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelPropertiesUpdateRequest handlerParcelPropertiesUpdateRequest = OnParcelPropertiesUpdateRequest;
+
+            if (handlerParcelPropertiesUpdateRequest != null)
+            {
+                LandUpdateArgs args = new LandUpdateArgs();
+
+                args.AuthBuyerID = parcelPropertiesPacket.ParcelData.AuthBuyerID;
+                args.Category = (ParcelCategory)parcelPropertiesPacket.ParcelData.Category;
+                args.Desc = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Desc);
+                args.GroupID = parcelPropertiesPacket.ParcelData.GroupID;
+                args.LandingType = parcelPropertiesPacket.ParcelData.LandingType;
+                args.MediaAutoScale = parcelPropertiesPacket.ParcelData.MediaAutoScale;
+                args.MediaID = parcelPropertiesPacket.ParcelData.MediaID;
+                args.MediaURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MediaURL);
+                args.MusicURL = Utils.BytesToString(parcelPropertiesPacket.ParcelData.MusicURL);
+                args.Name = Utils.BytesToString(parcelPropertiesPacket.ParcelData.Name);
+                args.ParcelFlags = parcelPropertiesPacket.ParcelData.ParcelFlags;
+                args.PassHours = parcelPropertiesPacket.ParcelData.PassHours;
+                args.PassPrice = parcelPropertiesPacket.ParcelData.PassPrice;
+                args.SalePrice = parcelPropertiesPacket.ParcelData.SalePrice;
+                args.SnapshotID = parcelPropertiesPacket.ParcelData.SnapshotID;
+                args.UserLocation = parcelPropertiesPacket.ParcelData.UserLocation;
+                args.UserLookAt = parcelPropertiesPacket.ParcelData.UserLookAt;
+                handlerParcelPropertiesUpdateRequest(args, parcelPropertiesPacket.ParcelData.LocalID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelSelectObjects(IClientAPI sender, Packet Pack)
+        {
+            ParcelSelectObjectsPacket selectPacket = (ParcelSelectObjectsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (selectPacket.AgentData.SessionID != SessionId ||
+                    selectPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            List<UUID> returnIDs = new List<UUID>();
+
+            foreach (ParcelSelectObjectsPacket.ReturnIDsBlock rb in
+                     selectPacket.ReturnIDs)
+            {
+                returnIDs.Add(rb.ReturnID);
+            }
+
+            ParcelSelectObjects handlerParcelSelectObjects = OnParcelSelectObjects;
+
+            if (handlerParcelSelectObjects != null)
+            {
+                handlerParcelSelectObjects(selectPacket.ParcelData.LocalID,
+                                           Convert.ToInt32(selectPacket.ParcelData.ReturnType), returnIDs, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelObjectOwnersRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelObjectOwnersRequestPacket reqPacket = (ParcelObjectOwnersRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (reqPacket.AgentData.SessionID != SessionId ||
+                    reqPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelObjectOwnerRequest handlerParcelObjectOwnerRequest = OnParcelObjectOwnerRequest;
+
+            if (handlerParcelObjectOwnerRequest != null)
+            {
+                handlerParcelObjectOwnerRequest(reqPacket.ParcelData.LocalID, this);
+            }
+            return true;
+
+        }
+
+        private bool HandleParcelGodForceOwner(IClientAPI sender, Packet Pack)
+        {
+            ParcelGodForceOwnerPacket godForceOwnerPacket = (ParcelGodForceOwnerPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (godForceOwnerPacket.AgentData.SessionID != SessionId ||
+                    godForceOwnerPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelGodForceOwner handlerParcelGodForceOwner = OnParcelGodForceOwner;
+            if (handlerParcelGodForceOwner != null)
+            {
+                handlerParcelGodForceOwner(godForceOwnerPacket.Data.LocalID, godForceOwnerPacket.Data.OwnerID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelRelease(IClientAPI sender, Packet Pack)
+        {
+            ParcelReleasePacket releasePacket = (ParcelReleasePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (releasePacket.AgentData.SessionID != SessionId ||
+                    releasePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelAbandonRequest handlerParcelAbandonRequest = OnParcelAbandonRequest;
+            if (handlerParcelAbandonRequest != null)
+            {
+                handlerParcelAbandonRequest(releasePacket.Data.LocalID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelReclaim(IClientAPI sender, Packet Pack)
+        {
+            ParcelReclaimPacket reclaimPacket = (ParcelReclaimPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (reclaimPacket.AgentData.SessionID != SessionId ||
+                    reclaimPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelReclaim handlerParcelReclaim = OnParcelReclaim;
+            if (handlerParcelReclaim != null)
+            {
+                handlerParcelReclaim(reclaimPacket.Data.LocalID, this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelReturnObjects(IClientAPI sender, Packet Pack)
+        {
+            ParcelReturnObjectsPacket parcelReturnObjects = (ParcelReturnObjectsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (parcelReturnObjects.AgentData.SessionID != SessionId ||
+                    parcelReturnObjects.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UUID[] puserselectedOwnerIDs = new UUID[parcelReturnObjects.OwnerIDs.Length];
+            for (int parceliterator = 0; parceliterator < parcelReturnObjects.OwnerIDs.Length; parceliterator++)
+                puserselectedOwnerIDs[parceliterator] = parcelReturnObjects.OwnerIDs[parceliterator].OwnerID;
+
+            UUID[] puserselectedTaskIDs = new UUID[parcelReturnObjects.TaskIDs.Length];
+
+            for (int parceliterator = 0; parceliterator < parcelReturnObjects.TaskIDs.Length; parceliterator++)
+                puserselectedTaskIDs[parceliterator] = parcelReturnObjects.TaskIDs[parceliterator].TaskID;
+
+            ParcelReturnObjectsRequest handlerParcelReturnObjectsRequest = OnParcelReturnObjectsRequest;
+            if (handlerParcelReturnObjectsRequest != null)
+            {
+                handlerParcelReturnObjectsRequest(parcelReturnObjects.ParcelData.LocalID, parcelReturnObjects.ParcelData.ReturnType, puserselectedOwnerIDs, puserselectedTaskIDs, this);
+
+            }
+            return true;
+        }
+
+        private bool HandleParcelSetOtherCleanTime(IClientAPI sender, Packet Pack)
+        {
+            ParcelSetOtherCleanTimePacket parcelSetOtherCleanTimePacket = (ParcelSetOtherCleanTimePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (parcelSetOtherCleanTimePacket.AgentData.SessionID != SessionId ||
+                    parcelSetOtherCleanTimePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelSetOtherCleanTime handlerParcelSetOtherCleanTime = OnParcelSetOtherCleanTime;
+            if (handlerParcelSetOtherCleanTime != null)
+            {
+                handlerParcelSetOtherCleanTime(this,
+                                               parcelSetOtherCleanTimePacket.ParcelData.LocalID,
+                                               parcelSetOtherCleanTimePacket.ParcelData.OtherCleanTime);
+            }
+            return true;
+        }
+
+        private bool HandleLandStatRequest(IClientAPI sender, Packet Pack)
+        {
+            LandStatRequestPacket lsrp = (LandStatRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (lsrp.AgentData.SessionID != SessionId ||
+                    lsrp.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GodLandStatRequest handlerLandStatRequest = OnLandStatRequest;
+            if (handlerLandStatRequest != null)
+            {
+                handlerLandStatRequest(lsrp.RequestData.ParcelLocalID, lsrp.RequestData.ReportType, lsrp.RequestData.RequestFlags, Utils.BytesToString(lsrp.RequestData.Filter), this);
+            }
+            return true;
+        }
+
+        private bool HandleParcelDwellRequest(IClientAPI sender, Packet Pack)
+        {
+            ParcelDwellRequestPacket dwellrq =
+                            (ParcelDwellRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dwellrq.AgentData.SessionID != SessionId ||
+                    dwellrq.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ParcelDwellRequest handlerParcelDwellRequest = OnParcelDwellRequest;
+            if (handlerParcelDwellRequest != null)
+            {
+                handlerParcelDwellRequest(dwellrq.Data.LocalID, this);
+            }
+            return true;
+        }
+
+        #endregion Parcel related packets
+
+        #region Estate Packets
+
+        private bool HandleEstateOwnerMessage(IClientAPI sender, Packet Pack)
+        {
+            EstateOwnerMessagePacket messagePacket = (EstateOwnerMessagePacket)Pack;
+            // m_log.InfoFormat("[LLCLIENTVIEW]: Packet: {0}", Utils.BytesToString(messagePacket.MethodData.Method));
+            GodLandStatRequest handlerLandStatRequest;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (messagePacket.AgentData.SessionID != SessionId ||
+                    messagePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            string method = Utils.BytesToString(messagePacket.MethodData.Method);
+
+            switch (method)
+            {
+                case "getinfo":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        OnDetailedEstateDataRequest(this, messagePacket.MethodData.Invoice);
+                    }
+                    return true;
+                case "setregioninfo":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        OnSetEstateFlagsRequest(convertParamStringToBool(messagePacket.ParamList[0].Parameter), convertParamStringToBool(messagePacket.ParamList[1].Parameter),
+                                                convertParamStringToBool(messagePacket.ParamList[2].Parameter), !convertParamStringToBool(messagePacket.ParamList[3].Parameter),
+                                                Convert.ToInt16(Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[4].Parameter), Culture.NumberFormatInfo)),
+                                                (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter), Culture.NumberFormatInfo),
+                                                Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[6].Parameter)),
+                                                convertParamStringToBool(messagePacket.ParamList[7].Parameter), convertParamStringToBool(messagePacket.ParamList[8].Parameter));
+                    }
+                    return true;
+                //                            case "texturebase":
+                //                                if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                //                                {
+                //                                    foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                //                                    {
+                //                                        string s = Utils.BytesToString(block.Parameter);
+                //                                        string[] splitField = s.Split(' ');
+                //                                        if (splitField.Length == 2)
+                //                                        {
+                //                                            UUID tempUUID = new UUID(splitField[1]);
+                //                                            OnSetEstateTerrainBaseTexture(this, Convert.ToInt16(splitField[0]), tempUUID);
+                //                                        }
+                //                                    }
+                //                                }
+                //                                break;
+                case "texturedetail":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                        {
+                            string s = Utils.BytesToString(block.Parameter);
+                            string[] splitField = s.Split(' ');
+                            if (splitField.Length == 2)
+                            {
+                                Int16 corner = Convert.ToInt16(splitField[0]);
+                                UUID textureUUID = new UUID(splitField[1]);
+
+                                OnSetEstateTerrainDetailTexture(this, corner, textureUUID);
+                            }
+                        }
+                    }
+
+                    return true;
+                case "textureheights":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                        {
+                            string s = Utils.BytesToString(block.Parameter);
+                            string[] splitField = s.Split(' ');
+                            if (splitField.Length == 3)
+                            {
+                                Int16 corner = Convert.ToInt16(splitField[0]);
+                                float lowValue = (float)Convert.ToDecimal(splitField[1], Culture.NumberFormatInfo);
+                                float highValue = (float)Convert.ToDecimal(splitField[2], Culture.NumberFormatInfo);
+
+                                OnSetEstateTerrainTextureHeights(this, corner, lowValue, highValue);
+                            }
+                        }
+                    }
+                    return true;
+                case "texturecommit":
+                    OnCommitEstateTerrainTextureRequest(this);
+                    return true;
+                case "setregionterrain":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        if (messagePacket.ParamList.Length != 9)
+                        {
+                            m_log.Error("EstateOwnerMessage: SetRegionTerrain method has a ParamList of invalid length");
+                        }
+                        else
+                        {
+                            try
+                            {
+                                string tmp = Utils.BytesToString(messagePacket.ParamList[0].Parameter);
+                                if (!tmp.Contains(".")) tmp += ".00";
+                                float WaterHeight = (float)Convert.ToDecimal(tmp, Culture.NumberFormatInfo);
+                                tmp = Utils.BytesToString(messagePacket.ParamList[1].Parameter);
+                                if (!tmp.Contains(".")) tmp += ".00";
+                                float TerrainRaiseLimit = (float)Convert.ToDecimal(tmp, Culture.NumberFormatInfo);
+                                tmp = Utils.BytesToString(messagePacket.ParamList[2].Parameter);
+                                if (!tmp.Contains(".")) tmp += ".00";
+                                float TerrainLowerLimit = (float)Convert.ToDecimal(tmp, Culture.NumberFormatInfo);
+                                bool UseEstateSun = convertParamStringToBool(messagePacket.ParamList[3].Parameter);
+                                bool UseFixedSun = convertParamStringToBool(messagePacket.ParamList[4].Parameter);
+                                float SunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[5].Parameter), Culture.NumberFormatInfo);
+                                bool UseGlobal = convertParamStringToBool(messagePacket.ParamList[6].Parameter);
+                                bool EstateFixedSun = convertParamStringToBool(messagePacket.ParamList[7].Parameter);
+                                float EstateSunHour = (float)Convert.ToDecimal(Utils.BytesToString(messagePacket.ParamList[8].Parameter), Culture.NumberFormatInfo);
+
+                                OnSetRegionTerrainSettings(WaterHeight, TerrainRaiseLimit, TerrainLowerLimit, UseEstateSun, UseFixedSun, SunHour, UseGlobal, EstateFixedSun, EstateSunHour);
+
+                            }
+                            catch (Exception ex)
+                            {
+                                m_log.Error("EstateOwnerMessage: Exception while setting terrain settings: \n" + messagePacket + "\n" + ex);
+                            }
+                        }
+                    }
+
+                    return true;
+                case "restart":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        // There's only 1 block in the estateResetSim..   and that's the number of seconds till restart.
+                        foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                        {
+                            float timeSeconds;
+                            Utils.TryParseSingle(Utils.BytesToString(block.Parameter), out timeSeconds);
+                            timeSeconds = (int)timeSeconds;
+                            OnEstateRestartSimRequest(this, (int)timeSeconds);
+
+                        }
+                    }
+                    return true;
+                case "estatechangecovenantid":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        foreach (EstateOwnerMessagePacket.ParamListBlock block in messagePacket.ParamList)
+                        {
+                            UUID newCovenantID = new UUID(Utils.BytesToString(block.Parameter));
+                            OnEstateChangeCovenantRequest(this, newCovenantID);
+                        }
+                    }
+                    return true;
+                case "estateaccessdelta": // Estate access delta manages the banlist and allow list too.
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        int estateAccessType = Convert.ToInt16(Utils.BytesToString(messagePacket.ParamList[1].Parameter));
+
+                        OnUpdateEstateAccessDeltaRequest(this, messagePacket.MethodData.Invoice, estateAccessType, new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter)));
+
+                    }
+                    return true;
+                case "simulatormessage":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
+                        string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);
+                        string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);
+                        UUID sessionID = messagePacket.AgentData.SessionID;
+                        OnSimulatorBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message);
+                    }
+                    return true;
+                case "instantmessage":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        if (messagePacket.ParamList.Length < 2)
+                            return true;
+
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID sessionID = messagePacket.AgentData.SessionID;
+
+                        UUID SenderID;
+                        string SenderName;
+                        string Message;
+
+                        if (messagePacket.ParamList.Length < 5)
+                        {
+                            SenderID = AgentId;
+                            SenderName = Utils.BytesToString(messagePacket.ParamList[0].Parameter);
+                            Message = Utils.BytesToString(messagePacket.ParamList[1].Parameter);
+                        }
+                        else
+                        {
+                            SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
+                            SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);
+                            Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);
+                        }
+
+                        OnEstateBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message);
+                    }
+                    return true;
+                case "setregiondebug":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        bool scripted = convertParamStringToBool(messagePacket.ParamList[0].Parameter);
+                        bool collisionEvents = convertParamStringToBool(messagePacket.ParamList[1].Parameter);
+                        bool physics = convertParamStringToBool(messagePacket.ParamList[2].Parameter);
+
+                        OnEstateDebugRegionRequest(this, invoice, SenderID, scripted, collisionEvents, physics);
+                    }
+                    return true;
+                case "teleporthomeuser":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        UUID Prey;
+
+                        UUID.TryParse(Utils.BytesToString(messagePacket.ParamList[1].Parameter), out Prey);
+
+                        OnEstateTeleportOneUserHomeRequest(this, invoice, SenderID, Prey);
+                    }
+                    return true;
+                case "teleporthomeallusers":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        OnEstateTeleportAllUsersHomeRequest(this, invoice, SenderID);
+                    }
+                    return true;
+                case "colliders":
+                    handlerLandStatRequest = OnLandStatRequest;
+                    if (handlerLandStatRequest != null)
+                    {
+                        handlerLandStatRequest(0, 1, 0, "", this);
+                    }
+                    return true;
+                case "scripts":
+                    handlerLandStatRequest = OnLandStatRequest;
+                    if (handlerLandStatRequest != null)
+                    {
+                        handlerLandStatRequest(0, 0, 0, "", this);
+                    }
+                    return true;
+                case "terrain":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        if (messagePacket.ParamList.Length > 0)
+                        {
+                            if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "bake")
+                            {
+                                BakeTerrain handlerBakeTerrain = OnBakeTerrain;
+                                if (handlerBakeTerrain != null)
+                                {
+                                    handlerBakeTerrain(this);
+                                }
+                            }
+                            if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "download filename")
+                            {
+                                if (messagePacket.ParamList.Length > 1)
+                                {
+                                    RequestTerrain handlerRequestTerrain = OnRequestTerrain;
+                                    if (handlerRequestTerrain != null)
+                                    {
+                                        handlerRequestTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter));
+                                    }
+                                }
+                            }
+                            if (Utils.BytesToString(messagePacket.ParamList[0].Parameter) == "upload filename")
+                            {
+                                if (messagePacket.ParamList.Length > 1)
+                                {
+                                    RequestTerrain handlerUploadTerrain = OnUploadTerrain;
+                                    if (handlerUploadTerrain != null)
+                                    {
+                                        handlerUploadTerrain(this, Utils.BytesToString(messagePacket.ParamList[1].Parameter));
+                                    }
+                                }
+                            }
+
+                        }
+
+
+                    }
+                    return true;
+
+                case "estatechangeinfo":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        UInt32 param1 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[1].Parameter));
+                        UInt32 param2 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
+
+                        EstateChangeInfo handlerEstateChangeInfo = OnEstateChangeInfo;
+                        if (handlerEstateChangeInfo != null)
+                        {
+                            handlerEstateChangeInfo(this, invoice, SenderID, param1, param2);
+                        }
+                    }
+                    return true;
+
+                case "telehub":
+                    if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        UInt32 param1 = 0u;
+
+                        string command = (string)Utils.BytesToString(messagePacket.ParamList[0].Parameter);
+
+                        if (command != "info ui")
+                        {
+                            try
+                            {
+                                param1 = Convert.ToUInt32(Utils.BytesToString(messagePacket.ParamList[1].Parameter));
+                            }
+                            catch
+                            {
+                            }
+                        }
+
+                        EstateManageTelehub handlerEstateManageTelehub = OnEstateManageTelehub;
+                        if (handlerEstateManageTelehub != null)
+                        {
+                            handlerEstateManageTelehub(this, invoice, SenderID, command, param1);
+                        }
+                    }
+                    return true;
+
+                case "kickestate":
+
+                    if(((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
+                    {
+                        UUID invoice = messagePacket.MethodData.Invoice;
+                        UUID SenderID = messagePacket.AgentData.AgentID;
+                        UUID Prey;
+
+                        UUID.TryParse(Utils.BytesToString(messagePacket.ParamList[0].Parameter), out Prey);
+
+                        OnEstateTeleportOneUserHomeRequest(this, invoice, SenderID, Prey);
+                    }
+                    return true;
+
+                default:
+                    m_log.WarnFormat(
+                        "[LLCLIENTVIEW]: EstateOwnerMessage: Unknown method {0} requested for {1} in {2}",
+                        method, Name, Scene.Name);
+
+                    for (int i = 0; i < messagePacket.ParamList.Length; i++)
+                    {
+                        EstateOwnerMessagePacket.ParamListBlock block = messagePacket.ParamList[i];
+                        string data = (string)Utils.BytesToString(block.Parameter);
+                        m_log.DebugFormat("[LLCLIENTVIEW]: Param {0}={1}", i, data);
+                    }
+
+                    return true;
+            }
+
+            //int parcelID, uint reportType, uint requestflags, string filter
+
+            //lsrp.RequestData.ParcelLocalID;
+            //lsrp.RequestData.ReportType; // 1 = colliders, 0 = scripts
+            //lsrp.RequestData.RequestFlags;
+            //lsrp.RequestData.Filter;
+        }
+
+        private bool HandleRequestRegionInfo(IClientAPI sender, Packet Pack)
+        {
+            RequestRegionInfoPacket.AgentDataBlock mPacket = ((RequestRegionInfoPacket)Pack).AgentData;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (mPacket.SessionID != SessionId ||
+                    mPacket.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RegionInfoRequest handlerRegionInfoRequest = OnRegionInfoRequest;
+            if (handlerRegionInfoRequest != null)
+            {
+                handlerRegionInfoRequest(this);
+            }
+            return true;
+        }
+
+        private bool HandleEstateCovenantRequest(IClientAPI sender, Packet Pack)
+        {
+
+            //EstateCovenantRequestPacket.AgentDataBlock epack =
+            //     ((EstateCovenantRequestPacket)Pack).AgentData;
+
+            EstateCovenantRequest handlerEstateCovenantRequest = OnEstateCovenantRequest;
+            if (handlerEstateCovenantRequest != null)
+            {
+                handlerEstateCovenantRequest(this);
+            }
+            return true;
+
+        }
+
+        #endregion Estate Packets
+
+        #region GodPackets
+
+        private bool HandleRequestGodlikePowers(IClientAPI sender, Packet Pack)
+        {
+            RequestGodlikePowersPacket rglpPack = (RequestGodlikePowersPacket)Pack;
+
+            if (rglpPack.AgentData.SessionID != SessionId ||
+                    rglpPack.AgentData.AgentID != AgentId)
+                return true;
+
+            RequestGodlikePowersPacket.RequestBlockBlock rblock = rglpPack.RequestBlock;
+            UUID token = rblock.Token;
+
+            RequestGodlikePowersPacket.AgentDataBlock ablock = rglpPack.AgentData;
+
+            RequestGodlikePowers handlerReqGodlikePowers = OnRequestGodlikePowers;
+
+            if (handlerReqGodlikePowers != null)
+            {
+                handlerReqGodlikePowers(ablock.AgentID, ablock.SessionID, token, rblock.Godlike);
+            }
+
+            return true;
+        }
+
+        private bool HandleGodUpdateRegionInfoUpdate(IClientAPI client, Packet Packet)
+        {
+            GodUpdateRegionInfoPacket GodUpdateRegionInfo =
+                (GodUpdateRegionInfoPacket)Packet;
+
+            if (GodUpdateRegionInfo.AgentData.SessionID != SessionId ||
+                    GodUpdateRegionInfo.AgentData.AgentID != AgentId)
+                return true;
+
+            GodUpdateRegionInfoUpdate handlerGodUpdateRegionInfo = OnGodUpdateRegionInfoUpdate;
+            if (handlerGodUpdateRegionInfo != null)
+            {
+                handlerGodUpdateRegionInfo(this,
+                                           GodUpdateRegionInfo.RegionInfo.BillableFactor,
+                                           GodUpdateRegionInfo.RegionInfo.EstateID,
+                                           GodUpdateRegionInfo.RegionInfo.RegionFlags,
+                                           GodUpdateRegionInfo.RegionInfo.SimName,
+                                           GodUpdateRegionInfo.RegionInfo.RedirectGridX,
+                                           GodUpdateRegionInfo.RegionInfo.RedirectGridY);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleSimWideDeletes(IClientAPI client, Packet Packet)
+        {
+            SimWideDeletesPacket SimWideDeletesRequest =
+                (SimWideDeletesPacket)Packet;
+            SimWideDeletesDelegate handlerSimWideDeletesRequest = OnSimWideDeletes;
+            if (handlerSimWideDeletesRequest != null)
+            {
+                handlerSimWideDeletesRequest(this, SimWideDeletesRequest.AgentData.AgentID,(int)SimWideDeletesRequest.DataBlock.Flags,SimWideDeletesRequest.DataBlock.TargetID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleGodlikeMessage(IClientAPI client, Packet Packet)
+        {
+            GodlikeMessagePacket GodlikeMessage =
+                (GodlikeMessagePacket)Packet;
+
+            if (GodlikeMessage.AgentData.SessionID != SessionId ||
+                    GodlikeMessage.AgentData.AgentID != AgentId)
+                return true;
+
+            GodlikeMessage handlerGodlikeMessage = onGodlikeMessage;
+            if (handlerGodlikeMessage != null)
+            {
+                handlerGodlikeMessage(this,
+                                      GodlikeMessage.MethodData.Invoice,
+                                      GodlikeMessage.MethodData.Method,
+                                      GodlikeMessage.ParamList[0].Parameter);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleSaveStatePacket(IClientAPI client, Packet Packet)
+        {
+            StateSavePacket SaveStateMessage =
+                (StateSavePacket)Packet;
+
+            if (SaveStateMessage.AgentData.SessionID != SessionId ||
+                    SaveStateMessage.AgentData.AgentID != AgentId)
+                return true;
+
+            SaveStateHandler handlerSaveStatePacket = OnSaveState;
+            if (handlerSaveStatePacket != null)
+            {
+                handlerSaveStatePacket(this,SaveStateMessage.AgentData.AgentID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleGodKickUser(IClientAPI sender, Packet Pack)
+        {
+            GodKickUserPacket gkupack = (GodKickUserPacket)Pack;
+
+            if (gkupack.UserInfo.GodSessionID != SessionId ||
+                    gkupack.UserInfo.GodID != AgentId)
+                return true;
+
+            GodKickUser handlerGodKickUser = OnGodKickUser;
+            if (handlerGodKickUser != null)
+            {
+                handlerGodKickUser(gkupack.UserInfo.GodID, gkupack.UserInfo.AgentID, gkupack.UserInfo.KickFlags, gkupack.UserInfo.Reason);
+            }
+
+            return true;
+        }
+        #endregion GodPackets
+
+        #region Economy/Transaction Packets
+
+        private bool HandleMoneyBalanceRequest(IClientAPI sender, Packet Pack)
+        {
+            MoneyBalanceRequestPacket moneybalancerequestpacket = (MoneyBalanceRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (moneybalancerequestpacket.AgentData.SessionID != SessionId ||
+                    moneybalancerequestpacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            MoneyBalanceRequest handlerMoneyBalanceRequest = OnMoneyBalanceRequest;
+
+            if (handlerMoneyBalanceRequest != null)
+            {
+                handlerMoneyBalanceRequest(this, moneybalancerequestpacket.AgentData.AgentID, moneybalancerequestpacket.AgentData.SessionID, moneybalancerequestpacket.MoneyData.TransactionID);
+            }
+
+            return true;
+        }
+        private bool HandleEconomyDataRequest(IClientAPI sender, Packet Pack)
+        {
+            EconomyDataRequest handlerEconomoyDataRequest = OnEconomyDataRequest;
+            if (handlerEconomoyDataRequest != null)
+            {
+                handlerEconomoyDataRequest(this);
+            }
+            return true;
+        }
+        private bool HandleRequestPayPrice(IClientAPI sender, Packet Pack)
+        {
+            RequestPayPricePacket requestPayPricePacket = (RequestPayPricePacket)Pack;
+
+            RequestPayPrice handlerRequestPayPrice = OnRequestPayPrice;
+            if (handlerRequestPayPrice != null)
+            {
+                handlerRequestPayPrice(this, requestPayPricePacket.ObjectData.ObjectID);
+            }
+            return true;
+        }
+        private bool HandleObjectSaleInfo(IClientAPI sender, Packet Pack)
+        {
+            ObjectSaleInfoPacket objectSaleInfoPacket = (ObjectSaleInfoPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objectSaleInfoPacket.AgentData.SessionID != SessionId ||
+                    objectSaleInfoPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectSaleInfo handlerObjectSaleInfo = OnObjectSaleInfo;
+            if (handlerObjectSaleInfo != null)
+            {
+                foreach (ObjectSaleInfoPacket.ObjectDataBlock d
+                    in objectSaleInfoPacket.ObjectData)
+                {
+                    handlerObjectSaleInfo(this,
+                                          objectSaleInfoPacket.AgentData.AgentID,
+                                          objectSaleInfoPacket.AgentData.SessionID,
+                                          d.LocalID,
+                                          d.SaleType,
+                                          d.SalePrice);
+                }
+            }
+            return true;
+        }
+        private bool HandleObjectBuy(IClientAPI sender, Packet Pack)
+        {
+            ObjectBuyPacket objectBuyPacket = (ObjectBuyPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objectBuyPacket.AgentData.SessionID != SessionId ||
+                    objectBuyPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ObjectBuy handlerObjectBuy = OnObjectBuy;
+
+            if (handlerObjectBuy != null)
+            {
+                foreach (ObjectBuyPacket.ObjectDataBlock d
+                    in objectBuyPacket.ObjectData)
+                {
+                    handlerObjectBuy(this,
+                                     objectBuyPacket.AgentData.AgentID,
+                                     objectBuyPacket.AgentData.SessionID,
+                                     objectBuyPacket.AgentData.GroupID,
+                                     objectBuyPacket.AgentData.CategoryID,
+                                     d.ObjectLocalID,
+                                     d.SaleType,
+                                     d.SalePrice);
+                }
+            }
+            return true;
+        }
+
+        #endregion Economy/Transaction Packets
+
+        #region Script Packets
+        private bool HandleGetScriptRunning(IClientAPI sender, Packet Pack)
+        {
+            GetScriptRunningPacket scriptRunning = (GetScriptRunningPacket)Pack;
+
+            GetScriptRunning handlerGetScriptRunning = OnGetScriptRunning;
+            if (handlerGetScriptRunning != null)
+            {
+                handlerGetScriptRunning(this, scriptRunning.Script.ObjectID, scriptRunning.Script.ItemID);
+            }
+            return true;
+        }
+        private bool HandleSetScriptRunning(IClientAPI sender, Packet Pack)
+        {
+            SetScriptRunningPacket setScriptRunning = (SetScriptRunningPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (setScriptRunning.AgentData.SessionID != SessionId ||
+                    setScriptRunning.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            SetScriptRunning handlerSetScriptRunning = OnSetScriptRunning;
+            if (handlerSetScriptRunning != null)
+            {
+                handlerSetScriptRunning(this, setScriptRunning.Script.ObjectID, setScriptRunning.Script.ItemID, setScriptRunning.Script.Running);
+            }
+            return true;
+        }
+
+        private bool HandleScriptReset(IClientAPI sender, Packet Pack)
+        {
+            ScriptResetPacket scriptResetPacket = (ScriptResetPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (scriptResetPacket.AgentData.SessionID != SessionId ||
+                    scriptResetPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ScriptReset handlerScriptReset = OnScriptReset;
+            if (handlerScriptReset != null)
+            {
+                handlerScriptReset(this, scriptResetPacket.Script.ObjectID, scriptResetPacket.Script.ItemID);
+            }
+            return true;
+        }
+
+        #endregion Script Packets
+
+        #region Gesture Managment
+
+        private bool HandleActivateGestures(IClientAPI sender, Packet Pack)
+        {
+            ActivateGesturesPacket activateGesturePacket = (ActivateGesturesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (activateGesturePacket.AgentData.SessionID != SessionId ||
+                    activateGesturePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ActivateGesture handlerActivateGesture = OnActivateGesture;
+            if (handlerActivateGesture != null)
+            {
+                handlerActivateGesture(this,
+                                       activateGesturePacket.Data[0].AssetID,
+                                       activateGesturePacket.Data[0].ItemID);
+            }
+            else m_log.Error("Null pointer for activateGesture");
+
+            return true;
+        }
+        private bool HandleDeactivateGestures(IClientAPI sender, Packet Pack)
+        {
+            DeactivateGesturesPacket deactivateGesturePacket = (DeactivateGesturesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (deactivateGesturePacket.AgentData.SessionID != SessionId ||
+                    deactivateGesturePacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DeactivateGesture handlerDeactivateGesture = OnDeactivateGesture;
+            if (handlerDeactivateGesture != null)
+            {
+                handlerDeactivateGesture(this, deactivateGesturePacket.Data[0].ItemID);
+            }
+            return true;
+        }
+        private bool HandleObjectOwner(IClientAPI sender, Packet Pack)
+        {
+            ObjectOwnerPacket objectOwnerPacket = (ObjectOwnerPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (objectOwnerPacket.AgentData.SessionID != SessionId ||
+                    objectOwnerPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            List<uint> localIDs = new List<uint>();
+
+            foreach (ObjectOwnerPacket.ObjectDataBlock d in objectOwnerPacket.ObjectData)
+                localIDs.Add(d.ObjectLocalID);
+
+            ObjectOwner handlerObjectOwner = OnObjectOwner;
+            if (handlerObjectOwner != null)
+            {
+                handlerObjectOwner(this, objectOwnerPacket.HeaderData.OwnerID, objectOwnerPacket.HeaderData.GroupID, localIDs);
+            }
+            return true;
+        }
+
+        #endregion Gesture Managment
+
+        private bool HandleAgentFOV(IClientAPI sender, Packet Pack)
+        {
+            AgentFOVPacket fovPacket = (AgentFOVPacket)Pack;
+
+            if (fovPacket.FOVBlock.GenCounter > m_agentFOVCounter)
+            {
+                m_agentFOVCounter = fovPacket.FOVBlock.GenCounter;
+                AgentFOV handlerAgentFOV = OnAgentFOV;
+                if (handlerAgentFOV != null)
+                {
+                    handlerAgentFOV(this, fovPacket.FOVBlock.VerticalAngle);
+                }
+            }
+            return true;
+        }
+
+        #region unimplemented handlers
+
+        private bool HandleViewerStats(IClientAPI sender, Packet Pack)
+        {
+            // TODO: handle this packet
+            //m_log.Warn("[CLIENT]: unhandled ViewerStats packet");
+            return true;
+        }
+
+        private bool HandleMapItemRequest(IClientAPI sender, Packet Pack)
+        {
+            MapItemRequestPacket mirpk = (MapItemRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (mirpk.AgentData.SessionID != SessionId ||
+                    mirpk.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            //m_log.Debug(mirpk.ToString());
+            MapItemRequest handlerMapItemRequest = OnMapItemRequest;
+            if (handlerMapItemRequest != null)
+            {
+                handlerMapItemRequest(this, mirpk.AgentData.Flags, mirpk.AgentData.EstateID,
+                                      mirpk.AgentData.Godlike, mirpk.RequestData.ItemType,
+                                      mirpk.RequestData.RegionHandle);
+
+            }
+            return true;
+        }
+
+        private bool HandleTransferAbort(IClientAPI sender, Packet Pack)
+        {
+            return true;
+        }
+
+        private bool HandleMuteListRequest(IClientAPI sender, Packet Pack)
+        {
+            MuteListRequestPacket muteListRequest =
+                            (MuteListRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (muteListRequest.AgentData.SessionID != SessionId ||
+                    muteListRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            MuteListRequest handlerMuteListRequest = OnMuteListRequest;
+            if (handlerMuteListRequest != null)
+            {
+                handlerMuteListRequest(this, muteListRequest.MuteData.MuteCRC);
+            }
+            else
+            {
+                 if(muteListRequest.MuteData.MuteCRC == 0)
+                    SendEmpytMuteList();
+                else
+                    SendUseCachedMuteList();
+            }
+            return true;           
+        }
+
+        private bool HandleUpdateMuteListEntry(IClientAPI client, Packet Packet)
+        {
+            UpdateMuteListEntryPacket UpdateMuteListEntry =
+                (UpdateMuteListEntryPacket)Packet;
+            MuteListEntryUpdate handlerUpdateMuteListEntry = OnUpdateMuteListEntry;
+            if (handlerUpdateMuteListEntry != null)
+            {
+                handlerUpdateMuteListEntry(this, UpdateMuteListEntry.MuteData.MuteID,
+                                           Utils.BytesToString(UpdateMuteListEntry.MuteData.MuteName),
+                                           UpdateMuteListEntry.MuteData.MuteType,
+                                           UpdateMuteListEntry.MuteData.MuteFlags);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleRemoveMuteListEntry(IClientAPI client, Packet Packet)
+        {
+            RemoveMuteListEntryPacket RemoveMuteListEntry =
+                (RemoveMuteListEntryPacket)Packet;
+            MuteListEntryRemove handlerRemoveMuteListEntry = OnRemoveMuteListEntry;
+            if (handlerRemoveMuteListEntry != null)
+            {
+                handlerRemoveMuteListEntry(this,
+                                           RemoveMuteListEntry.MuteData.MuteID,
+                                           Utils.BytesToString(RemoveMuteListEntry.MuteData.MuteName));
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleUserReport(IClientAPI client, Packet Packet)
+        {
+            UserReportPacket UserReport =
+                (UserReportPacket)Packet;
+
+            NewUserReport handlerUserReport = OnUserReport;
+            if (handlerUserReport != null)
+            {
+                handlerUserReport(this,
+                    Utils.BytesToString(UserReport.ReportData.AbuseRegionName),
+                    UserReport.ReportData.AbuserID,
+                    UserReport.ReportData.Category,
+                    UserReport.ReportData.CheckFlags,
+                    Utils.BytesToString(UserReport.ReportData.Details),
+                    UserReport.ReportData.ObjectID,
+                    UserReport.ReportData.Position,
+                    UserReport.ReportData.ReportType,
+                    UserReport.ReportData.ScreenshotID,
+                    Utils.BytesToString(UserReport.ReportData.Summary),
+                    UserReport.AgentData.AgentID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleSendPostcard(IClientAPI client, Packet packet)
+        {
+//            SendPostcardPacket SendPostcard =
+//                (SendPostcardPacket)packet;
+            SendPostcard handlerSendPostcard = OnSendPostcard;
+            if (handlerSendPostcard != null)
+            {
+                handlerSendPostcard(this);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleChangeInventoryItemFlags(IClientAPI client, Packet packet)
+        {
+            ChangeInventoryItemFlagsPacket ChangeInventoryItemFlags =
+                (ChangeInventoryItemFlagsPacket)packet;
+            ChangeInventoryItemFlags handlerChangeInventoryItemFlags = OnChangeInventoryItemFlags;
+            if (handlerChangeInventoryItemFlags != null)
+            {
+                foreach(ChangeInventoryItemFlagsPacket.InventoryDataBlock b in ChangeInventoryItemFlags.InventoryData)
+                    handlerChangeInventoryItemFlags(this, b.ItemID, b.Flags);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleUseCircuitCode(IClientAPI sender, Packet Pack)
+        {
+            return true;
+        }
+
+        private bool HandleCreateNewOutfitAttachments(IClientAPI sender, Packet Pack)
+        {
+            CreateNewOutfitAttachmentsPacket packet = (CreateNewOutfitAttachmentsPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (packet.AgentData.SessionID != SessionId ||
+                    packet.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+            MoveItemsAndLeaveCopy handlerMoveItemsAndLeaveCopy = null;
+            List<InventoryItemBase> items = new List<InventoryItemBase>();
+            foreach (CreateNewOutfitAttachmentsPacket.ObjectDataBlock n in packet.ObjectData)
+            {
+                InventoryItemBase b = new InventoryItemBase();
+                b.ID = n.OldItemID;
+                b.Folder = n.OldFolderID;
+                items.Add(b);
+            }
+
+            handlerMoveItemsAndLeaveCopy = OnMoveItemsAndLeaveCopy;
+            if (handlerMoveItemsAndLeaveCopy != null)
+            {
+                handlerMoveItemsAndLeaveCopy(this, items, packet.HeaderData.NewFolderID);
+            }
+
+            return true;
+        }
+
+        private bool HandleAgentHeightWidth(IClientAPI sender, Packet Pack)
+        {
+            return true;
+        }
+
+
+        private bool HandleInventoryDescendents(IClientAPI sender, Packet Pack)
+        {
+            return true;
+        }
+
+        #endregion unimplemented handlers
+
+        #region Dir handlers
+
+        private bool HandleDirPlacesQuery(IClientAPI sender, Packet Pack)
+        {
+            DirPlacesQueryPacket dirPlacesQueryPacket = (DirPlacesQueryPacket)Pack;
+            //m_log.Debug(dirPlacesQueryPacket.ToString());
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirPlacesQueryPacket.AgentData.SessionID != SessionId ||
+                    dirPlacesQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirPlacesQuery handlerDirPlacesQuery = OnDirPlacesQuery;
+            if (handlerDirPlacesQuery != null)
+            {
+                handlerDirPlacesQuery(this,
+                                      dirPlacesQueryPacket.QueryData.QueryID,
+                                      Utils.BytesToString(
+                                          dirPlacesQueryPacket.QueryData.QueryText),
+                                      (int)dirPlacesQueryPacket.QueryData.QueryFlags,
+                                      (int)dirPlacesQueryPacket.QueryData.Category,
+                                      Utils.BytesToString(
+                                          dirPlacesQueryPacket.QueryData.SimName),
+                                      dirPlacesQueryPacket.QueryData.QueryStart);
+            }
+            return true;
+        }
+
+        private bool HandleDirFindQuery(IClientAPI sender, Packet Pack)
+        {
+            DirFindQueryPacket dirFindQueryPacket = (DirFindQueryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirFindQueryPacket.AgentData.SessionID != SessionId ||
+                    dirFindQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirFindQuery handlerDirFindQuery = OnDirFindQuery;
+            if (handlerDirFindQuery != null)
+            {
+                handlerDirFindQuery(this,
+                                    dirFindQueryPacket.QueryData.QueryID,
+                                    Utils.BytesToString(
+                                        dirFindQueryPacket.QueryData.QueryText).Trim(),
+                                    dirFindQueryPacket.QueryData.QueryFlags,
+                                    dirFindQueryPacket.QueryData.QueryStart);
+            }
+            return true;
+        }
+
+        private bool HandleDirLandQuery(IClientAPI sender, Packet Pack)
+        {
+            DirLandQueryPacket dirLandQueryPacket = (DirLandQueryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirLandQueryPacket.AgentData.SessionID != SessionId ||
+                    dirLandQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirLandQuery handlerDirLandQuery = OnDirLandQuery;
+            if (handlerDirLandQuery != null)
+            {
+                handlerDirLandQuery(this,
+                                    dirLandQueryPacket.QueryData.QueryID,
+                                    dirLandQueryPacket.QueryData.QueryFlags,
+                                    dirLandQueryPacket.QueryData.SearchType,
+                                    dirLandQueryPacket.QueryData.Price,
+                                    dirLandQueryPacket.QueryData.Area,
+                                    dirLandQueryPacket.QueryData.QueryStart);
+            }
+            return true;
+        }
+
+        private bool HandleDirPopularQuery(IClientAPI sender, Packet Pack)
+        {
+            DirPopularQueryPacket dirPopularQueryPacket = (DirPopularQueryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirPopularQueryPacket.AgentData.SessionID != SessionId ||
+                    dirPopularQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirPopularQuery handlerDirPopularQuery = OnDirPopularQuery;
+            if (handlerDirPopularQuery != null)
+            {
+                handlerDirPopularQuery(this,
+                                       dirPopularQueryPacket.QueryData.QueryID,
+                                       dirPopularQueryPacket.QueryData.QueryFlags);
+            }
+            return true;
+        }
+
+        private bool HandleDirClassifiedQuery(IClientAPI sender, Packet Pack)
+        {
+            DirClassifiedQueryPacket dirClassifiedQueryPacket = (DirClassifiedQueryPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (dirClassifiedQueryPacket.AgentData.SessionID != SessionId ||
+                    dirClassifiedQueryPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            DirClassifiedQuery handlerDirClassifiedQuery = OnDirClassifiedQuery;
+            if (handlerDirClassifiedQuery != null)
+            {
+                handlerDirClassifiedQuery(this,
+                                          dirClassifiedQueryPacket.QueryData.QueryID,
+                                          Utils.BytesToString(
+                                              dirClassifiedQueryPacket.QueryData.QueryText),
+                                          dirClassifiedQueryPacket.QueryData.QueryFlags,
+                                          dirClassifiedQueryPacket.QueryData.Category,
+                                          dirClassifiedQueryPacket.QueryData.QueryStart);
+            }
+            return true;
+        }
+
+        private bool HandleEventInfoRequest(IClientAPI sender, Packet Pack)
+        {
+            EventInfoRequestPacket eventInfoRequestPacket = (EventInfoRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (eventInfoRequestPacket.AgentData.SessionID != SessionId ||
+                    eventInfoRequestPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnEventInfoRequest != null)
+            {
+                OnEventInfoRequest(this, eventInfoRequestPacket.EventData.EventID);
+            }
+            return true;
+        }
+
+        #endregion
+
+        #region Calling Card
+
+        private bool HandleOfferCallingCard(IClientAPI sender, Packet Pack)
+        {
+            OfferCallingCardPacket offerCallingCardPacket = (OfferCallingCardPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (offerCallingCardPacket.AgentData.SessionID != SessionId ||
+                    offerCallingCardPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnOfferCallingCard != null)
+            {
+                OnOfferCallingCard(this,
+                                   offerCallingCardPacket.AgentBlock.DestID,
+                                   offerCallingCardPacket.AgentBlock.TransactionID);
+            }
+            return true;
+        }
+
+        private bool HandleAcceptCallingCard(IClientAPI sender, Packet Pack)
+        {
+            AcceptCallingCardPacket acceptCallingCardPacket = (AcceptCallingCardPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (acceptCallingCardPacket.AgentData.SessionID != SessionId ||
+                    acceptCallingCardPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            // according to http://wiki.secondlife.com/wiki/AcceptCallingCard FolderData should
+            // contain exactly one entry
+            if (OnAcceptCallingCard != null && acceptCallingCardPacket.FolderData.Length > 0)
+            {
+                OnAcceptCallingCard(this,
+                                    acceptCallingCardPacket.TransactionBlock.TransactionID,
+                                    acceptCallingCardPacket.FolderData[0].FolderID);
+            }
+            return true;
+        }
+
+        private bool HandleDeclineCallingCard(IClientAPI sender, Packet Pack)
+        {
+            DeclineCallingCardPacket declineCallingCardPacket = (DeclineCallingCardPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (declineCallingCardPacket.AgentData.SessionID != SessionId ||
+                    declineCallingCardPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (OnDeclineCallingCard != null)
+            {
+                OnDeclineCallingCard(this,
+                                     declineCallingCardPacket.TransactionBlock.TransactionID);
+            }
+            return true;
+        }
+
+        #endregion Calling Card
+
+        #region Groups
+
+        private bool HandleActivateGroup(IClientAPI sender, Packet Pack)
+        {
+            ActivateGroupPacket activateGroupPacket = (ActivateGroupPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (activateGroupPacket.AgentData.SessionID != SessionId ||
+                    activateGroupPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.ActivateGroup(this, activateGroupPacket.AgentData.GroupID);
+            }
+            return true;
+
+        }
+
+        private bool HandleGroupVoteHistoryRequest(IClientAPI client, Packet Packet)
+        {
+            GroupVoteHistoryRequestPacket GroupVoteHistoryRequest =
+                (GroupVoteHistoryRequestPacket)Packet;
+            GroupVoteHistoryRequest handlerGroupVoteHistoryRequest = OnGroupVoteHistoryRequest;
+            if (handlerGroupVoteHistoryRequest != null)
+            {
+                handlerGroupVoteHistoryRequest(this, GroupVoteHistoryRequest.AgentData.AgentID,GroupVoteHistoryRequest.AgentData.SessionID,GroupVoteHistoryRequest.GroupData.GroupID,GroupVoteHistoryRequest.TransactionData.TransactionID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleGroupActiveProposalsRequest(IClientAPI client, Packet Packet)
+        {
+            GroupActiveProposalsRequestPacket GroupActiveProposalsRequest =
+                (GroupActiveProposalsRequestPacket)Packet;
+            GroupActiveProposalsRequest handlerGroupActiveProposalsRequest = OnGroupActiveProposalsRequest;
+            if (handlerGroupActiveProposalsRequest != null)
+            {
+                handlerGroupActiveProposalsRequest(this, GroupActiveProposalsRequest.AgentData.AgentID,GroupActiveProposalsRequest.AgentData.SessionID,GroupActiveProposalsRequest.GroupData.GroupID,GroupActiveProposalsRequest.TransactionData.TransactionID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleGroupAccountDetailsRequest(IClientAPI client, Packet Packet)
+        {
+            GroupAccountDetailsRequestPacket GroupAccountDetailsRequest =
+                (GroupAccountDetailsRequestPacket)Packet;
+            GroupAccountDetailsRequest handlerGroupAccountDetailsRequest = OnGroupAccountDetailsRequest;
+            if (handlerGroupAccountDetailsRequest != null)
+            {
+                handlerGroupAccountDetailsRequest(this, GroupAccountDetailsRequest.AgentData.AgentID,GroupAccountDetailsRequest.AgentData.GroupID,GroupAccountDetailsRequest.MoneyData.RequestID,GroupAccountDetailsRequest.AgentData.SessionID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleGroupAccountSummaryRequest(IClientAPI client, Packet Packet)
+        {
+            GroupAccountSummaryRequestPacket GroupAccountSummaryRequest =
+                (GroupAccountSummaryRequestPacket)Packet;
+            GroupAccountSummaryRequest handlerGroupAccountSummaryRequest = OnGroupAccountSummaryRequest;
+            if (handlerGroupAccountSummaryRequest != null)
+            {
+                handlerGroupAccountSummaryRequest(this, GroupAccountSummaryRequest.AgentData.AgentID,GroupAccountSummaryRequest.AgentData.GroupID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleGroupTransactionsDetailsRequest(IClientAPI client, Packet Packet)
+        {
+            GroupAccountTransactionsRequestPacket GroupAccountTransactionsRequest =
+                (GroupAccountTransactionsRequestPacket)Packet;
+            GroupAccountTransactionsRequest handlerGroupAccountTransactionsRequest = OnGroupAccountTransactionsRequest;
+            if (handlerGroupAccountTransactionsRequest != null)
+            {
+                handlerGroupAccountTransactionsRequest(this, GroupAccountTransactionsRequest.AgentData.AgentID,GroupAccountTransactionsRequest.AgentData.GroupID,GroupAccountTransactionsRequest.MoneyData.RequestID,GroupAccountTransactionsRequest.AgentData.SessionID);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleGroupTitlesRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupTitlesRequestPacket groupTitlesRequest =
+                            (GroupTitlesRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupTitlesRequest.AgentData.SessionID != SessionId ||
+                    groupTitlesRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                GroupTitlesReplyPacket groupTitlesReply = (GroupTitlesReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupTitlesReply);
+
+                groupTitlesReply.AgentData =
+                    new GroupTitlesReplyPacket.AgentDataBlock();
+
+                groupTitlesReply.AgentData.AgentID = AgentId;
+                groupTitlesReply.AgentData.GroupID =
+                    groupTitlesRequest.AgentData.GroupID;
+
+                groupTitlesReply.AgentData.RequestID =
+                    groupTitlesRequest.AgentData.RequestID;
+
+                List<GroupTitlesData> titles =
+                    m_GroupsModule.GroupTitlesRequest(this,
+                                                      groupTitlesRequest.AgentData.GroupID);
+
+                groupTitlesReply.GroupData =
+                    new GroupTitlesReplyPacket.GroupDataBlock[titles.Count];
+
+                int i = 0;
+                foreach (GroupTitlesData d in titles)
+                {
+                    groupTitlesReply.GroupData[i] =
+                        new GroupTitlesReplyPacket.GroupDataBlock();
+
+                    groupTitlesReply.GroupData[i].Title =
+                        Util.StringToBytes256(d.Name);
+                    groupTitlesReply.GroupData[i].RoleID =
+                        d.UUID;
+                    groupTitlesReply.GroupData[i].Selected =
+                        d.Selected;
+                    i++;
+                }
+
+                OutPacket(groupTitlesReply, ThrottleOutPacketType.Task);
+            }
+            return true;
+        }
+
+        UUID lastGroupProfileRequestID = UUID.Zero;
+        double lastGroupProfileRequestTS = Util.GetTimeStampMS();
+
+        private bool HandleGroupProfileRequest(IClientAPI sender, Packet Pack)
+        {
+            if(m_GroupsModule == null)
+                return true;
+
+            GroupProfileRequestPacket groupProfileRequest =
+                       (GroupProfileRequestPacket)Pack;
+
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupProfileRequest.AgentData.SessionID != SessionId ||
+                    groupProfileRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            UUID grpID = groupProfileRequest.GroupData.GroupID;
+            double ts = Util.GetTimeStampMS();
+            if(grpID == lastGroupProfileRequestID && ts - lastGroupProfileRequestTS < 10000)
+                return true;
+
+            lastGroupProfileRequestID = grpID;
+            lastGroupProfileRequestTS = ts;
+
+            GroupProfileReplyPacket groupProfileReply = (GroupProfileReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupProfileReply);
+
+            groupProfileReply.AgentData = new GroupProfileReplyPacket.AgentDataBlock();
+            groupProfileReply.GroupData = new GroupProfileReplyPacket.GroupDataBlock();
+            groupProfileReply.AgentData.AgentID = AgentId;
+
+            GroupProfileData d = m_GroupsModule.GroupProfileRequest(this,
+                                                                    groupProfileRequest.GroupData.GroupID);
+
+            if(d.GroupID == UUID.Zero) // don't send broken data
+                return true;
+
+            groupProfileReply.GroupData.GroupID = d.GroupID;
+            groupProfileReply.GroupData.Name = Util.StringToBytes256(d.Name);
+            groupProfileReply.GroupData.Charter = Util.StringToBytes1024(d.Charter);
+            groupProfileReply.GroupData.ShowInList = d.ShowInList;
+            groupProfileReply.GroupData.MemberTitle = Util.StringToBytes256(d.MemberTitle);
+            groupProfileReply.GroupData.PowersMask = d.PowersMask;
+            groupProfileReply.GroupData.InsigniaID = d.InsigniaID;
+            groupProfileReply.GroupData.FounderID = d.FounderID;
+            groupProfileReply.GroupData.MembershipFee = d.MembershipFee;
+            groupProfileReply.GroupData.OpenEnrollment = d.OpenEnrollment;
+            groupProfileReply.GroupData.Money = d.Money;
+            groupProfileReply.GroupData.GroupMembershipCount = d.GroupMembershipCount;
+            groupProfileReply.GroupData.GroupRolesCount = d.GroupRolesCount;
+            groupProfileReply.GroupData.AllowPublish = d.AllowPublish;
+            groupProfileReply.GroupData.MaturePublish = d.MaturePublish;
+            groupProfileReply.GroupData.OwnerRole = d.OwnerRole;
+
+            Scene scene = (Scene)m_scene;
+            if (scene.Permissions.IsGod(sender.AgentId) && (!sender.IsGroupMember(groupProfileRequest.GroupData.GroupID)))
+            {
+                ScenePresence p;
+                if (scene.TryGetScenePresence(sender.AgentId, out p))
+                {
+                    if (p.IsViewerUIGod)
+                    {
+                        groupProfileReply.GroupData.OpenEnrollment = true;
+                        groupProfileReply.GroupData.MembershipFee = 0;
+                    }
+                }
+            }
+
+            OutPacket(groupProfileReply, ThrottleOutPacketType.Task);
+
+            if(grpID == lastGroupProfileRequestID)
+                lastGroupProfileRequestTS = Util.GetTimeStampMS() - 7000;
+
+            return true;
+        }
+        private bool HandleGroupMembersRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupMembersRequestPacket groupMembersRequestPacket =
+                        (GroupMembersRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupMembersRequestPacket.AgentData.SessionID != SessionId ||
+                    groupMembersRequestPacket.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                List<GroupMembersData> members =
+                    m_GroupsModule.GroupMembersRequest(this, groupMembersRequestPacket.GroupData.GroupID);
+
+                int memberCount = members.Count;
+                int indx = 0;
+                while (indx < memberCount)
+                {
+                    int blockCount = memberCount - indx;
+                    if (blockCount > 25)
+                        blockCount = 25;
+
+                    GroupMembersReplyPacket groupMembersReply = (GroupMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupMembersReply);
+
+                    groupMembersReply.AgentData =
+                        new GroupMembersReplyPacket.AgentDataBlock();
+                    groupMembersReply.GroupData =
+                        new GroupMembersReplyPacket.GroupDataBlock();
+                    groupMembersReply.MemberData =
+                        new GroupMembersReplyPacket.MemberDataBlock[
+                            blockCount];
+
+                    groupMembersReply.AgentData.AgentID = AgentId;
+                    groupMembersReply.GroupData.GroupID =
+                        groupMembersRequestPacket.GroupData.GroupID;
+                    groupMembersReply.GroupData.RequestID =
+                        groupMembersRequestPacket.GroupData.RequestID;
+                    groupMembersReply.GroupData.MemberCount = memberCount;
+
+                    for (int i = 0; i < blockCount; i++)
+                    {
+                        GroupMembersData m = members[indx++];
+
+                        groupMembersReply.MemberData[i] =
+                            new GroupMembersReplyPacket.MemberDataBlock();
+                        groupMembersReply.MemberData[i].AgentID =
+                            m.AgentID;
+                        groupMembersReply.MemberData[i].Contribution =
+                            m.Contribution;
+                        groupMembersReply.MemberData[i].OnlineStatus =
+                            Util.StringToBytes256(m.OnlineStatus);
+                        groupMembersReply.MemberData[i].AgentPowers =
+                            m.AgentPowers;
+                        groupMembersReply.MemberData[i].Title =
+                            Util.StringToBytes256(m.Title);
+                        groupMembersReply.MemberData[i].IsOwner =
+                            m.IsOwner;
+                    }
+                    OutPacket(groupMembersReply, ThrottleOutPacketType.Task);
+                }
+            }
+            return true;
+        }
+        private bool HandleGroupRoleDataRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupRoleDataRequestPacket groupRolesRequest =
+                        (GroupRoleDataRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupRolesRequest.AgentData.SessionID != SessionId ||
+                    groupRolesRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                GroupRoleDataReplyPacket groupRolesReply = (GroupRoleDataReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleDataReply);
+
+                groupRolesReply.AgentData =
+                    new GroupRoleDataReplyPacket.AgentDataBlock();
+
+                groupRolesReply.AgentData.AgentID = AgentId;
+
+                groupRolesReply.GroupData =
+                    new GroupRoleDataReplyPacket.GroupDataBlock();
+
+                groupRolesReply.GroupData.GroupID =
+                    groupRolesRequest.GroupData.GroupID;
+
+                groupRolesReply.GroupData.RequestID =
+                    groupRolesRequest.GroupData.RequestID;
+
+                List<GroupRolesData> titles =
+                    m_GroupsModule.GroupRoleDataRequest(this,
+                                                        groupRolesRequest.GroupData.GroupID);
+
+                groupRolesReply.GroupData.RoleCount =
+                    titles.Count;
+
+                groupRolesReply.RoleData =
+                    new GroupRoleDataReplyPacket.RoleDataBlock[titles.Count];
+
+                int i = 0;
+                foreach (GroupRolesData d in titles)
+                {
+                    groupRolesReply.RoleData[i] =
+                        new GroupRoleDataReplyPacket.RoleDataBlock();
+
+                    groupRolesReply.RoleData[i].RoleID =
+                        d.RoleID;
+                    groupRolesReply.RoleData[i].Name =
+                        Util.StringToBytes256(d.Name);
+                    groupRolesReply.RoleData[i].Title =
+                        Util.StringToBytes256(d.Title);
+                    groupRolesReply.RoleData[i].Description =
+                        Util.StringToBytes1024(d.Description);
+                    groupRolesReply.RoleData[i].Powers =
+                        d.Powers;
+                    groupRolesReply.RoleData[i].Members =
+                        (uint)d.Members;
+
+                    i++;
+                }
+
+                OutPacket(groupRolesReply, ThrottleOutPacketType.Task);
+            }
+            return true;
+        }
+
+        private bool HandleGroupRoleMembersRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupRoleMembersRequestPacket groupRoleMembersRequest =
+                       (GroupRoleMembersRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupRoleMembersRequest.AgentData.SessionID != SessionId ||
+                    groupRoleMembersRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                List<GroupRoleMembersData> mappings =
+                        m_GroupsModule.GroupRoleMembersRequest(this,
+                        groupRoleMembersRequest.GroupData.GroupID);
+
+                int mappingsCount = mappings.Count;
+
+                while (mappings.Count > 0)
+                {
+                    int pairs = mappings.Count;
+                    if (pairs > 32)
+                        pairs = 32;
+
+                    GroupRoleMembersReplyPacket groupRoleMembersReply = (GroupRoleMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupRoleMembersReply);
+                    groupRoleMembersReply.AgentData =
+                            new GroupRoleMembersReplyPacket.AgentDataBlock();
+                    groupRoleMembersReply.AgentData.AgentID =
+                            AgentId;
+                    groupRoleMembersReply.AgentData.GroupID =
+                            groupRoleMembersRequest.GroupData.GroupID;
+                    groupRoleMembersReply.AgentData.RequestID =
+                            groupRoleMembersRequest.GroupData.RequestID;
+
+                    groupRoleMembersReply.AgentData.TotalPairs =
+                            (uint)mappingsCount;
+
+                    groupRoleMembersReply.MemberData =
+                            new GroupRoleMembersReplyPacket.MemberDataBlock[pairs];
+
+                    for (int i = 0; i < pairs; i++)
+                    {
+                        GroupRoleMembersData d = mappings[0];
+                        mappings.RemoveAt(0);
+
+                        groupRoleMembersReply.MemberData[i] =
+                            new GroupRoleMembersReplyPacket.MemberDataBlock();
+
+                        groupRoleMembersReply.MemberData[i].RoleID =
+                                d.RoleID;
+                        groupRoleMembersReply.MemberData[i].MemberID =
+                                d.MemberID;
+                    }
+
+                    OutPacket(groupRoleMembersReply, ThrottleOutPacketType.Task);
+                }
+            }
+            return true;
+        }
+        private bool HandleCreateGroupRequest(IClientAPI sender, Packet Pack)
+        {
+            CreateGroupRequestPacket createGroupRequest =
+                       (CreateGroupRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (createGroupRequest.AgentData.SessionID != SessionId ||
+                    createGroupRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.CreateGroup(this,
+                                           Utils.BytesToString(createGroupRequest.GroupData.Name),
+                                           Utils.BytesToString(createGroupRequest.GroupData.Charter),
+                                           createGroupRequest.GroupData.ShowInList,
+                                           createGroupRequest.GroupData.InsigniaID,
+                                           createGroupRequest.GroupData.MembershipFee,
+                                           createGroupRequest.GroupData.OpenEnrollment,
+                                           createGroupRequest.GroupData.AllowPublish,
+                                           createGroupRequest.GroupData.MaturePublish);
+            }
+            return true;
+        }
+        private bool HandleUpdateGroupInfo(IClientAPI sender, Packet Pack)
+        {
+            UpdateGroupInfoPacket updateGroupInfo =
+                        (UpdateGroupInfoPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (updateGroupInfo.AgentData.SessionID != SessionId ||
+                    updateGroupInfo.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.UpdateGroupInfo(this,
+                                               updateGroupInfo.GroupData.GroupID,
+                                               Utils.BytesToString(updateGroupInfo.GroupData.Charter),
+                                               updateGroupInfo.GroupData.ShowInList,
+                                               updateGroupInfo.GroupData.InsigniaID,
+                                               updateGroupInfo.GroupData.MembershipFee,
+                                               updateGroupInfo.GroupData.OpenEnrollment,
+                                               updateGroupInfo.GroupData.AllowPublish,
+                                               updateGroupInfo.GroupData.MaturePublish);
+            }
+
+            return true;
+        }
+        private bool HandleSetGroupAcceptNotices(IClientAPI sender, Packet Pack)
+        {
+            SetGroupAcceptNoticesPacket setGroupAcceptNotices =
+                        (SetGroupAcceptNoticesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (setGroupAcceptNotices.AgentData.SessionID != SessionId ||
+                    setGroupAcceptNotices.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.SetGroupAcceptNotices(this,
+                                                     setGroupAcceptNotices.Data.GroupID,
+                                                     setGroupAcceptNotices.Data.AcceptNotices,
+                                                     setGroupAcceptNotices.NewData.ListInProfile);
+            }
+
+            return true;
+        }
+        private bool HandleGroupTitleUpdate(IClientAPI sender, Packet Pack)
+        {
+            GroupTitleUpdatePacket groupTitleUpdate =
+                        (GroupTitleUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupTitleUpdate.AgentData.SessionID != SessionId ||
+                    groupTitleUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.GroupTitleUpdate(this,
+                                                groupTitleUpdate.AgentData.GroupID,
+                                                groupTitleUpdate.AgentData.TitleRoleID);
+            }
+
+            return true;
+        }
+        private bool HandleParcelDeedToGroup(IClientAPI sender, Packet Pack)
+        {
+            ParcelDeedToGroupPacket parcelDeedToGroup = (ParcelDeedToGroupPacket)Pack;
+            if (m_GroupsModule != null)
+            {
+                ParcelDeedToGroup handlerParcelDeedToGroup = OnParcelDeedToGroup;
+                if (handlerParcelDeedToGroup != null)
+                {
+                    handlerParcelDeedToGroup(parcelDeedToGroup.Data.LocalID, parcelDeedToGroup.Data.GroupID, this);
+
+                }
+            }
+
+            return true;
+        }
+        private bool HandleGroupNoticesListRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupNoticesListRequestPacket groupNoticesListRequest =
+                        (GroupNoticesListRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupNoticesListRequest.AgentData.SessionID != SessionId ||
+                    groupNoticesListRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                GroupNoticeData[] gn =
+                    m_GroupsModule.GroupNoticesListRequest(this,
+                                                           groupNoticesListRequest.Data.GroupID);
+
+                GroupNoticesListReplyPacket groupNoticesListReply = (GroupNoticesListReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupNoticesListReply);
+                groupNoticesListReply.AgentData =
+                    new GroupNoticesListReplyPacket.AgentDataBlock();
+                groupNoticesListReply.AgentData.AgentID = AgentId;
+                groupNoticesListReply.AgentData.GroupID = groupNoticesListRequest.Data.GroupID;
+
+                groupNoticesListReply.Data = new GroupNoticesListReplyPacket.DataBlock[gn.Length];
+
+                int i = 0;
+                foreach (GroupNoticeData g in gn)
+                {
+                    groupNoticesListReply.Data[i] = new GroupNoticesListReplyPacket.DataBlock();
+                    groupNoticesListReply.Data[i].NoticeID =
+                        g.NoticeID;
+                    groupNoticesListReply.Data[i].Timestamp =
+                        g.Timestamp;
+                    groupNoticesListReply.Data[i].FromName =
+                        Util.StringToBytes256(g.FromName);
+                    groupNoticesListReply.Data[i].Subject =
+                        Util.StringToBytes256(g.Subject);
+                    groupNoticesListReply.Data[i].HasAttachment =
+                        g.HasAttachment;
+                    groupNoticesListReply.Data[i].AssetType =
+                        g.AssetType;
+                    i++;
+                }
+
+                OutPacket(groupNoticesListReply, ThrottleOutPacketType.Task);
+            }
+
+            return true;
+        }
+        private bool HandleGroupNoticeRequest(IClientAPI sender, Packet Pack)
+        {
+            GroupNoticeRequestPacket groupNoticeRequest =
+                        (GroupNoticeRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupNoticeRequest.AgentData.SessionID != SessionId ||
+                    groupNoticeRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.GroupNoticeRequest(this,
+                                                  groupNoticeRequest.Data.GroupNoticeID);
+            }
+            return true;
+        }
+        private bool HandleGroupRoleUpdate(IClientAPI sender, Packet Pack)
+        {
+            GroupRoleUpdatePacket groupRoleUpdate =
+                        (GroupRoleUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupRoleUpdate.AgentData.SessionID != SessionId ||
+                    groupRoleUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                foreach (GroupRoleUpdatePacket.RoleDataBlock d in
+                    groupRoleUpdate.RoleData)
+                {
+                    m_GroupsModule.GroupRoleUpdate(this,
+                                                   groupRoleUpdate.AgentData.GroupID,
+                                                   d.RoleID,
+                                                   Utils.BytesToString(d.Name),
+                                                   Utils.BytesToString(d.Description),
+                                                   Utils.BytesToString(d.Title),
+                                                   d.Powers,
+                                                   d.UpdateType);
+                }
+                m_GroupsModule.NotifyChange(groupRoleUpdate.AgentData.GroupID);
+            }
+            return true;
+        }
+        private bool HandleGroupRoleChanges(IClientAPI sender, Packet Pack)
+        {
+            GroupRoleChangesPacket groupRoleChanges =
+                        (GroupRoleChangesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (groupRoleChanges.AgentData.SessionID != SessionId ||
+                    groupRoleChanges.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                foreach (GroupRoleChangesPacket.RoleChangeBlock d in
+                    groupRoleChanges.RoleChange)
+                {
+                    m_GroupsModule.GroupRoleChanges(this,
+                                                    groupRoleChanges.AgentData.GroupID,
+                                                    d.RoleID,
+                                                    d.MemberID,
+                                                    d.Change);
+                }
+                m_GroupsModule.NotifyChange(groupRoleChanges.AgentData.GroupID);
+            }
+            return true;
+        }
+        private bool HandleJoinGroupRequest(IClientAPI sender, Packet Pack)
+        {
+            JoinGroupRequestPacket joinGroupRequest =
+                        (JoinGroupRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (joinGroupRequest.AgentData.SessionID != SessionId ||
+                    joinGroupRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.JoinGroupRequest(this,
+                        joinGroupRequest.GroupData.GroupID);
+            }
+            return true;
+        }
+        private bool HandleLeaveGroupRequest(IClientAPI sender, Packet Pack)
+        {
+            LeaveGroupRequestPacket leaveGroupRequest =
+                        (LeaveGroupRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (leaveGroupRequest.AgentData.SessionID != SessionId ||
+                    leaveGroupRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                m_GroupsModule.LeaveGroupRequest(this,
+                        leaveGroupRequest.GroupData.GroupID);
+            }
+            return true;
+        }
+        private bool HandleEjectGroupMemberRequest(IClientAPI sender, Packet Pack)
+        {
+            EjectGroupMemberRequestPacket ejectGroupMemberRequest =
+                       (EjectGroupMemberRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (ejectGroupMemberRequest.AgentData.SessionID != SessionId ||
+                    ejectGroupMemberRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                foreach (EjectGroupMemberRequestPacket.EjectDataBlock e
+                        in ejectGroupMemberRequest.EjectData)
+                {
+                    m_GroupsModule.EjectGroupMemberRequest(this,
+                            ejectGroupMemberRequest.GroupData.GroupID,
+                            e.EjecteeID);
+                }
+            }
+            return true;
+        }
+        private bool HandleInviteGroupRequest(IClientAPI sender, Packet Pack)
+        {
+            InviteGroupRequestPacket inviteGroupRequest =
+                        (InviteGroupRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (inviteGroupRequest.AgentData.SessionID != SessionId ||
+                    inviteGroupRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            if (m_GroupsModule != null)
+            {
+                foreach (InviteGroupRequestPacket.InviteDataBlock b in
+                        inviteGroupRequest.InviteData)
+                {
+                    m_GroupsModule.InviteGroupRequest(this,
+                            inviteGroupRequest.GroupData.GroupID,
+                            b.InviteeID,
+                            b.RoleID);
+                }
+            }
+            return true;
+        }
+
+        #endregion Groups
+
+        private bool HandleStartLure(IClientAPI sender, Packet Pack)
+        {
+            StartLurePacket startLureRequest = (StartLurePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (startLureRequest.AgentData.SessionID != SessionId ||
+                    startLureRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            StartLure handlerStartLure = OnStartLure;
+            if (handlerStartLure != null)
+            {
+                for (int i = 0 ; i < startLureRequest.TargetData.Length ; i++)
+                {
+                    handlerStartLure(startLureRequest.Info.LureType,
+                                     Utils.BytesToString(
+                                             startLureRequest.Info.Message),
+                                     startLureRequest.TargetData[i].TargetID,
+                                     this);
+                }
+            }
+            return true;
+        }
+        private bool HandleTeleportLureRequest(IClientAPI sender, Packet Pack)
+        {
+            TeleportLureRequestPacket teleportLureRequest =
+                            (TeleportLureRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (teleportLureRequest.Info.SessionID != SessionId ||
+                    teleportLureRequest.Info.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            TeleportLureRequest handlerTeleportLureRequest = OnTeleportLureRequest;
+            if (handlerTeleportLureRequest != null)
+                handlerTeleportLureRequest(
+                         teleportLureRequest.Info.LureID,
+                         teleportLureRequest.Info.TeleportFlags,
+                         this);
+            return true;
+        }
+        private bool HandleClassifiedInfoRequest(IClientAPI sender, Packet Pack)
+        {
+            ClassifiedInfoRequestPacket classifiedInfoRequest =
+                            (ClassifiedInfoRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (classifiedInfoRequest.AgentData.SessionID != SessionId ||
+                    classifiedInfoRequest.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ClassifiedInfoRequest handlerClassifiedInfoRequest = OnClassifiedInfoRequest;
+            if (handlerClassifiedInfoRequest != null)
+                handlerClassifiedInfoRequest(
+                         classifiedInfoRequest.Data.ClassifiedID,
+                         this);
+            return true;
+        }
+        private bool HandleClassifiedInfoUpdate(IClientAPI sender, Packet Pack)
+        {
+            ClassifiedInfoUpdatePacket classifiedInfoUpdate =
+                            (ClassifiedInfoUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (classifiedInfoUpdate.AgentData.SessionID != SessionId ||
+                    classifiedInfoUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ClassifiedInfoUpdate handlerClassifiedInfoUpdate = OnClassifiedInfoUpdate;
+            if (handlerClassifiedInfoUpdate != null)
+                handlerClassifiedInfoUpdate(
+                        classifiedInfoUpdate.Data.ClassifiedID,
+                        classifiedInfoUpdate.Data.Category,
+                        Utils.BytesToString(
+                                classifiedInfoUpdate.Data.Name),
+                        Utils.BytesToString(
+                                classifiedInfoUpdate.Data.Desc),
+                        classifiedInfoUpdate.Data.ParcelID,
+                        classifiedInfoUpdate.Data.ParentEstate,
+                        classifiedInfoUpdate.Data.SnapshotID,
+                        new Vector3(
+                            classifiedInfoUpdate.Data.PosGlobal),
+                        classifiedInfoUpdate.Data.ClassifiedFlags,
+                        classifiedInfoUpdate.Data.PriceForListing,
+                        this);
+            return true;
+        }
+        private bool HandleClassifiedDelete(IClientAPI sender, Packet Pack)
+        {
+            ClassifiedDeletePacket classifiedDelete =
+                           (ClassifiedDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (classifiedDelete.AgentData.SessionID != SessionId ||
+                    classifiedDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ClassifiedDelete handlerClassifiedDelete = OnClassifiedDelete;
+            if (handlerClassifiedDelete != null)
+                handlerClassifiedDelete(
+                         classifiedDelete.Data.ClassifiedID,
+                         this);
+            return true;
+        }
+        private bool HandleClassifiedGodDelete(IClientAPI sender, Packet Pack)
+        {
+            ClassifiedGodDeletePacket classifiedGodDelete =
+                            (ClassifiedGodDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (classifiedGodDelete.AgentData.SessionID != SessionId ||
+                    classifiedGodDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            ClassifiedGodDelete handlerClassifiedGodDelete = OnClassifiedGodDelete;
+            if (handlerClassifiedGodDelete != null)
+                handlerClassifiedGodDelete(
+                         classifiedGodDelete.Data.ClassifiedID,
+                         classifiedGodDelete.Data.QueryID,
+                         this);
+            return true;
+        }
+        private bool HandleEventGodDelete(IClientAPI sender, Packet Pack)
+        {
+            EventGodDeletePacket eventGodDelete =
+                               (EventGodDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (eventGodDelete.AgentData.SessionID != SessionId ||
+                    eventGodDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            EventGodDelete handlerEventGodDelete = OnEventGodDelete;
+            if (handlerEventGodDelete != null)
+                handlerEventGodDelete(
+                        eventGodDelete.EventData.EventID,
+                        eventGodDelete.QueryData.QueryID,
+                        Utils.BytesToString(
+                                eventGodDelete.QueryData.QueryText),
+                        eventGodDelete.QueryData.QueryFlags,
+                        eventGodDelete.QueryData.QueryStart,
+                        this);
+            return true;
+        }
+        private bool HandleEventNotificationAddRequest(IClientAPI sender, Packet Pack)
+        {
+            EventNotificationAddRequestPacket eventNotificationAdd =
+                            (EventNotificationAddRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (eventNotificationAdd.AgentData.SessionID != SessionId ||
+                    eventNotificationAdd.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            EventNotificationAddRequest handlerEventNotificationAddRequest = OnEventNotificationAddRequest;
+            if (handlerEventNotificationAddRequest != null)
+                handlerEventNotificationAddRequest(
+                        eventNotificationAdd.EventData.EventID, this);
+            return true;
+        }
+        private bool HandleEventNotificationRemoveRequest(IClientAPI sender, Packet Pack)
+        {
+            EventNotificationRemoveRequestPacket eventNotificationRemove =
+                            (EventNotificationRemoveRequestPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (eventNotificationRemove.AgentData.SessionID != SessionId ||
+                    eventNotificationRemove.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            EventNotificationRemoveRequest handlerEventNotificationRemoveRequest = OnEventNotificationRemoveRequest;
+            if (handlerEventNotificationRemoveRequest != null)
+                handlerEventNotificationRemoveRequest(
+                        eventNotificationRemove.EventData.EventID, this);
+            return true;
+        }
+        private bool HandleRetrieveInstantMessages(IClientAPI sender, Packet Pack)
+        {
+            RetrieveInstantMessagesPacket rimpInstantMessagePack = (RetrieveInstantMessagesPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (rimpInstantMessagePack.AgentData.SessionID != SessionId ||
+                    rimpInstantMessagePack.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            RetrieveInstantMessages handlerRetrieveInstantMessages = OnRetrieveInstantMessages;
+            if (handlerRetrieveInstantMessages != null)
+                handlerRetrieveInstantMessages(this);
+            return true;
+        }
+        private bool HandlePickDelete(IClientAPI sender, Packet Pack)
+        {
+            PickDeletePacket pickDelete =
+                            (PickDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (pickDelete.AgentData.SessionID != SessionId ||
+                    pickDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            PickDelete handlerPickDelete = OnPickDelete;
+            if (handlerPickDelete != null)
+                handlerPickDelete(this, pickDelete.Data.PickID);
+            return true;
+        }
+        private bool HandlePickGodDelete(IClientAPI sender, Packet Pack)
+        {
+            PickGodDeletePacket pickGodDelete =
+                           (PickGodDeletePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (pickGodDelete.AgentData.SessionID != SessionId ||
+                    pickGodDelete.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            PickGodDelete handlerPickGodDelete = OnPickGodDelete;
+            if (handlerPickGodDelete != null)
+                handlerPickGodDelete(this,
+                        pickGodDelete.AgentData.AgentID,
+                        pickGodDelete.Data.PickID,
+                        pickGodDelete.Data.QueryID);
+            return true;
+        }
+        private bool HandlePickInfoUpdate(IClientAPI sender, Packet Pack)
+        {
+            PickInfoUpdatePacket pickInfoUpdate =
+                            (PickInfoUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (pickInfoUpdate.AgentData.SessionID != SessionId ||
+                    pickInfoUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            PickInfoUpdate handlerPickInfoUpdate = OnPickInfoUpdate;
+            if (handlerPickInfoUpdate != null)
+                handlerPickInfoUpdate(this,
+                        pickInfoUpdate.Data.PickID,
+                        pickInfoUpdate.Data.CreatorID,
+                        pickInfoUpdate.Data.TopPick,
+                        Utils.BytesToString(pickInfoUpdate.Data.Name),
+                        Utils.BytesToString(pickInfoUpdate.Data.Desc),
+                        pickInfoUpdate.Data.SnapshotID,
+                        pickInfoUpdate.Data.SortOrder,
+                        pickInfoUpdate.Data.Enabled);
+            return true;
+        }
+        private bool HandleAvatarNotesUpdate(IClientAPI sender, Packet Pack)
+        {
+            AvatarNotesUpdatePacket avatarNotesUpdate =
+                            (AvatarNotesUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avatarNotesUpdate.AgentData.SessionID != SessionId ||
+                    avatarNotesUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            AvatarNotesUpdate handlerAvatarNotesUpdate = OnAvatarNotesUpdate;
+            if (handlerAvatarNotesUpdate != null)
+                handlerAvatarNotesUpdate(this,
+                        avatarNotesUpdate.Data.TargetID,
+                        Utils.BytesToString(avatarNotesUpdate.Data.Notes));
+            return true;
+        }
+        private bool HandleAvatarInterestsUpdate(IClientAPI sender, Packet Pack)
+        {
+            AvatarInterestsUpdatePacket avatarInterestUpdate =
+                            (AvatarInterestsUpdatePacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (avatarInterestUpdate.AgentData.SessionID != SessionId ||
+                    avatarInterestUpdate.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            AvatarInterestUpdate handlerAvatarInterestUpdate = OnAvatarInterestUpdate;
+            if (handlerAvatarInterestUpdate != null)
+                handlerAvatarInterestUpdate(this,
+                    avatarInterestUpdate.PropertiesData.WantToMask,
+                    Utils.BytesToString(avatarInterestUpdate.PropertiesData.WantToText),
+                    avatarInterestUpdate.PropertiesData.SkillsMask,
+                    Utils.BytesToString(avatarInterestUpdate.PropertiesData.SkillsText),
+                    Utils.BytesToString(avatarInterestUpdate.PropertiesData.LanguagesText));
+            return true;
+        }
+
+        private bool HandleGrantUserRights(IClientAPI sender, Packet Pack)
+        {
+            GrantUserRightsPacket GrantUserRights =
+                            (GrantUserRightsPacket)Pack;
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (GrantUserRights.AgentData.SessionID != SessionId ||
+                    GrantUserRights.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            GrantUserFriendRights GrantUserRightsHandler = OnGrantUserRights;
+            if (GrantUserRightsHandler != null)
+                GrantUserRightsHandler(this,
+                    GrantUserRights.Rights[0].AgentRelated,
+                    GrantUserRights.Rights[0].RelatedRights);
+
+            return true;
+        }
+
+        private bool HandleRevokePermissions(IClientAPI sender, Packet Pack)
+        {
+            RevokePermissionsPacket pkt = (RevokePermissionsPacket)Pack;
+            if (pkt.AgentData.SessionID != SessionId ||
+                    pkt .AgentData.AgentID != AgentId)
+                return true;
+
+            // don't use multidelegate "event"
+            ScenePresence sp = (ScenePresence)SceneAgent;
+            if(sp != null && !sp.IsDeleted && !sp.IsInTransit)
+            {
+                UUID objectID = pkt.Data.ObjectID;
+                uint permissions = pkt.Data.ObjectPermissions;
+
+                sp.HandleRevokePermissions(objectID , permissions);
+            }
+            return true;
+        }
+        private bool HandlePlacesQuery(IClientAPI sender, Packet Pack)
+        {
+            PlacesQueryPacket placesQueryPacket =
+                            (PlacesQueryPacket)Pack;
+
+            PlacesQuery handlerPlacesQuery = OnPlacesQuery;
+
+            if (handlerPlacesQuery != null)
+                handlerPlacesQuery(placesQueryPacket.AgentData.QueryID,
+                        placesQueryPacket.TransactionData.TransactionID,
+                        Utils.BytesToString(
+                                placesQueryPacket.QueryData.QueryText),
+                        placesQueryPacket.QueryData.QueryFlags,
+                        (byte)placesQueryPacket.QueryData.Category,
+                        Utils.BytesToString(
+                                placesQueryPacket.QueryData.SimName),
+                        this);
+            return true;
+        }
+
+        #endregion Packet Handlers
+
+        public void SendScriptQuestion(UUID taskID, string taskName, string ownerName, UUID itemID, int question)
+        {
+            ScriptQuestionPacket scriptQuestion = (ScriptQuestionPacket)PacketPool.Instance.GetPacket(PacketType.ScriptQuestion);
+            scriptQuestion.Data = new ScriptQuestionPacket.DataBlock();
+            // TODO: don't create new blocks if recycling an old packet
+            scriptQuestion.Data.TaskID = taskID;
+            scriptQuestion.Data.ItemID = itemID;
+            scriptQuestion.Data.Questions = question;
+            scriptQuestion.Data.ObjectName = Util.StringToBytes256(taskName);
+            scriptQuestion.Data.ObjectOwner = Util.StringToBytes256(ownerName);
+
+            OutPacket(scriptQuestion, ThrottleOutPacketType.Task);
+        }
+
+        /// <summary>
+        /// Handler called when we receive a logout packet.
+        /// </summary>
+        /// <param name="client"></param>
+        /// <param name="packet"></param>
+        /// <returns></returns>
+        protected virtual bool HandleLogout(IClientAPI client, Packet packet)
+        {
+            if (packet.Type == PacketType.LogoutRequest)
+            {
+                if (((LogoutRequestPacket)packet).AgentData.SessionID != SessionId) return false;
+            }
+
+            return Logout(client);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="client"></param>
+        /// <returns></returns>
+        protected virtual bool Logout(IClientAPI client)
+        {
+            m_log.InfoFormat("[CLIENT]: Got a logout request for {0} in {1}", Name, Scene.RegionInfo.RegionName);
+
+            Action<IClientAPI> handlerLogout = OnLogout;
+
+            if (handlerLogout != null)
+            {
+                handlerLogout(client);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// </summary>
+        /// <remarks>
+        /// At the moment, we always reply that there is no cached texture.
+        /// </remarks>
+        /// <param name="simclient"></param>
+        /// <param name="packet"></param>
+        /// <returns></returns>
+
+        protected bool HandleAgentTextureCached(IClientAPI simclient, Packet packet)
+        {
+            //m_log.Debug("texture cached: " + packet.ToString());
+            AgentCachedTexturePacket cachedtex = (AgentCachedTexturePacket)packet;
+            AgentCachedTextureResponsePacket cachedresp = (AgentCachedTextureResponsePacket)PacketPool.Instance.GetPacket(PacketType.AgentCachedTextureResponse);
+
+            if (cachedtex.AgentData.SessionID != SessionId)
+                return false;
+
+            // TODO: don't create new blocks if recycling an old packet
+            cachedresp.AgentData.AgentID = AgentId;
+            cachedresp.AgentData.SessionID = m_sessionId;
+            cachedresp.AgentData.SerialNum = cachedtex.AgentData.SerialNum;
+            cachedresp.WearableData =
+                new AgentCachedTextureResponsePacket.WearableDataBlock[cachedtex.WearableData.Length];
+
+            int cacheHits = 0;
+
+            // We need to make sure the asset stored in the bake is available on this server also by it's assetid before we map it to a Cacheid
+
+            WearableCacheItem[] cacheItems = null;
+
+            ScenePresence p = m_scene.GetScenePresence(AgentId);
+
+            if (p != null && p.Appearance != null)
+            {
+                cacheItems = p.Appearance.WearableCacheItems;
+            }
+
+            int maxWearablesLoop = cachedtex.WearableData.Length;
+
+            if (cacheItems != null)
+            {
+                if (maxWearablesLoop > cacheItems.Length)
+                    maxWearablesLoop = cacheItems.Length;
+                for (int i = 0; i < maxWearablesLoop; i++)
+                {
+                    int idx = cachedtex.WearableData[i].TextureIndex;
+                    cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
+                    cachedresp.WearableData[i].TextureIndex = cachedtex.WearableData[i].TextureIndex;
+                    cachedresp.WearableData[i].HostName = new byte[0];
+                    if (cachedtex.WearableData[i].ID == cacheItems[idx].CacheId)
+                    {
+                        cachedresp.WearableData[i].TextureID = cacheItems[idx].TextureID;
+                        cacheHits++;
+                    }
+                    else
+                    {
+                        cachedresp.WearableData[i].TextureID = UUID.Zero;
+                    }
+                }
+            }
+            else
+            {
+                for (int i = 0; i < maxWearablesLoop; i++)
+                {
+                    cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
+                    cachedresp.WearableData[i].TextureIndex = cachedtex.WearableData[i].TextureIndex;
+                    cachedresp.WearableData[i].TextureID = UUID.Zero;
+                    cachedresp.WearableData[i].HostName = new byte[0];
+                }
+            }
+
+            //m_log.DebugFormat("texture cached: hits {0}", cacheHits);
+
+            cachedresp.Header.Zerocoded = true;
+            OutPacket(cachedresp, ThrottleOutPacketType.Task);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Send a response back to a client when it asks the asset server (via the region server) if it has
+        /// its appearance texture cached.
+        /// </summary>
+        /// <param name="avatar"></param>
+        /// <param name="serial"></param>
+        /// <param name="cachedTextures"></param>
+        /// <returns></returns>
+        public void SendCachedTextureResponse(ISceneEntity avatar, int serial, List<CachedTextureResponseArg> cachedTextures)
+        {
+            ScenePresence presence = avatar as ScenePresence;
+            if (presence == null)
+                return;
+
+            AgentCachedTextureResponsePacket cachedresp = (AgentCachedTextureResponsePacket)PacketPool.Instance.GetPacket(PacketType.AgentCachedTextureResponse);
+
+            // TODO: don't create new blocks if recycling an old packet
+            cachedresp.AgentData.AgentID = m_agentId;
+            cachedresp.AgentData.SessionID = m_sessionId;
+            cachedresp.AgentData.SerialNum = serial;
+            cachedresp.WearableData = new AgentCachedTextureResponsePacket.WearableDataBlock[cachedTextures.Count];
+
+            for (int i = 0; i < cachedTextures.Count; i++)
+            {
+                cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
+                cachedresp.WearableData[i].TextureIndex = (byte)cachedTextures[i].BakedTextureIndex;
+                cachedresp.WearableData[i].TextureID = cachedTextures[i].BakedTextureID;
+                cachedresp.WearableData[i].HostName = new byte[0];
+            }
+
+            cachedresp.Header.Zerocoded = true;
+            OutPacket(cachedresp, ThrottleOutPacketType.Task);
+        }
+
+        protected bool HandleMultipleObjUpdate(IClientAPI simClient, Packet packet)
+        {
+            MultipleObjectUpdatePacket multipleupdate = (MultipleObjectUpdatePacket)packet;
+
+            if (multipleupdate.AgentData.SessionID != SessionId)
+                return false;
+
+//            m_log.DebugFormat(
+//                "[CLIENT]: Incoming MultipleObjectUpdatePacket contained {0} blocks", multipleupdate.ObjectData.Length);
+
+            Scene tScene = (Scene)m_scene;
+
+            for (int i = 0; i < multipleupdate.ObjectData.Length; i++)
+            {
+                MultipleObjectUpdatePacket.ObjectDataBlock block = multipleupdate.ObjectData[i];
+
+                // Can't act on Null Data
+                if (block.Data != null)
+                {
+                    uint localId = block.ObjectLocalID;
+                    SceneObjectPart part = tScene.GetSceneObjectPart(localId);
+
+                    if (part == null)
+                    {
+                        // It's a ghost! tell the client to delete it from view.
+                        simClient.SendKillObject(new List<uint> { localId });
+                    }
+                    else
+                    {
+                        ClientChangeObject updatehandler = onClientChangeObject;
+
+                        if (updatehandler != null)
+                        {
+                            ObjectChangeData udata = new ObjectChangeData();
+
+                            /*ubit from ll JIRA:
+                             * 0x01 position
+                             * 0x02 rotation
+                             * 0x04 scale
+
+                             * 0x08 LINK_SET
+                             * 0x10 UNIFORM for scale
+                             */
+
+                            // translate to internal changes
+                            // not all cases .. just the ones older code did
+
+                            switch (block.Type)
+                            {
+                                case 1: //change position sp
+                                    udata.position = new Vector3(block.Data, 0);
+
+                                    udata.change = ObjectChangeType.primP;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 2: // rotation sp
+                                    udata.rotation = new Quaternion(block.Data, 0, true);
+
+                                    udata.change = ObjectChangeType.primR;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 3: // position plus rotation
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.rotation = new Quaternion(block.Data, 12, true);
+
+                                    udata.change = ObjectChangeType.primPR;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 4: // scale sp
+                                    udata.scale = new Vector3(block.Data, 0);
+                                    udata.change = ObjectChangeType.primS;
+
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 0x14: // uniform scale sp
+                                    udata.scale = new Vector3(block.Data, 0);
+
+                                    udata.change = ObjectChangeType.primUS;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 5: // scale and position sp
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.scale = new Vector3(block.Data, 12);
+
+                                    udata.change = ObjectChangeType.primPS;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 0x15: //uniform scale and position
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.scale = new Vector3(block.Data, 12);
+
+                                    udata.change = ObjectChangeType.primPUS;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                // now group related (bit 4)
+                                case 9: //( 8 + 1 )group position
+                                    udata.position = new Vector3(block.Data, 0);
+
+                                    udata.change = ObjectChangeType.groupP;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 0x0A: // (8 + 2) group rotation
+                                    udata.rotation = new Quaternion(block.Data, 0, true);
+
+                                    udata.change = ObjectChangeType.groupR;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 0x0B: //( 8 + 2 + 1) group rotation and position
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.rotation = new Quaternion(block.Data, 12, true);
+
+                                    udata.change = ObjectChangeType.groupPR;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 0x0C: // (8 + 4) group scale
+                                    // only afects root prim and only sent by viewer editor object tab scaling
+                                    // mouse edition only allows uniform scaling
+                                    // SL MAY CHANGE THIS in viewers
+
+                                    udata.scale = new Vector3(block.Data, 0);
+
+                                    udata.change = ObjectChangeType.groupS;
+                                    updatehandler(localId, udata, this);
+
+                                    break;
+
+                                case 0x0D: //(8 + 4 + 1) group scale and position
+                                    // exception as above
+
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.scale = new Vector3(block.Data, 12);
+
+                                    udata.change = ObjectChangeType.groupPS;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 0x1C: // (0x10 + 8 + 4 ) group scale UNIFORM
+                                    udata.scale = new Vector3(block.Data, 0);
+
+                                    udata.change = ObjectChangeType.groupUS;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                case 0x1D: // (UNIFORM + GROUP + SCALE + POS)
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.scale = new Vector3(block.Data, 12);
+
+                                    udata.change = ObjectChangeType.groupPUS;
+                                    updatehandler(localId, udata, this);
+                                    break;
+
+                                default:
+                                    m_log.Debug("[CLIENT]: MultipleObjUpdate recieved an unknown packet type: " + (block.Type));
+                                    break;
+                            }
+                        }
+
+                    }
+                }
+            }
+            return true;
+        }
+
+        public void RequestMapLayer()
+        {
+            //should be getting the map layer from the grid server
+            //send a layer covering the 800,800 - 1200,1200 area (should be covering the requested area)
+            MapLayerReplyPacket mapReply = (MapLayerReplyPacket)PacketPool.Instance.GetPacket(PacketType.MapLayerReply);
+            // TODO: don't create new blocks if recycling an old packet
+            mapReply.AgentData.AgentID = AgentId;
+            mapReply.AgentData.Flags = 0;
+            mapReply.LayerData = new MapLayerReplyPacket.LayerDataBlock[1];
+            mapReply.LayerData[0] = new MapLayerReplyPacket.LayerDataBlock();
+            mapReply.LayerData[0].Bottom = 0;
+            mapReply.LayerData[0].Left = 0;
+            mapReply.LayerData[0].Top = 30000;
+            mapReply.LayerData[0].Right = 30000;
+            mapReply.LayerData[0].ImageID = new UUID("00000000-0000-1111-9999-000000000006");
+            mapReply.Header.Zerocoded = true;
+            OutPacket(mapReply, ThrottleOutPacketType.Land);
+        }
+
+        public void RequestMapBlocksX(int minX, int minY, int maxX, int maxY)
+        {
+            /*
+            IList simMapProfiles = m_gridServer.RequestMapBlocks(minX, minY, maxX, maxY);
+            MapBlockReplyPacket mbReply = new MapBlockReplyPacket();
+            mbReply.AgentData.AgentId = AgentId;
+            int len;
+            if (simMapProfiles == null)
+                len = 0;
+            else
+                len = simMapProfiles.Count;
+
+            mbReply.Data = new MapBlockReplyPacket.DataBlock[len];
+            int iii;
+            for (iii = 0; iii < len; iii++)
+            {
+                Hashtable mp = (Hashtable)simMapProfiles[iii];
+                mbReply.Data[iii] = new MapBlockReplyPacket.DataBlock();
+                mbReply.Data[iii].Name = Util.UTF8.GetBytes((string)mp["name"]);
+                mbReply.Data[iii].Access = System.Convert.ToByte(mp["access"]);
+                mbReply.Data[iii].Agents = System.Convert.ToByte(mp["agents"]);
+                mbReply.Data[iii].MapImageID = new UUID((string)mp["map-image-id"]);
+                mbReply.Data[iii].RegionFlags = System.Convert.ToUInt32(mp["region-flags"]);
+                mbReply.Data[iii].WaterHeight = System.Convert.ToByte(mp["water-height"]);
+                mbReply.Data[iii].X = System.Convert.ToUInt16(mp["x"]);
+                mbReply.Data[iii].Y = System.Convert.ToUInt16(mp["y"]);
+            }
+            this.OutPacket(mbReply, ThrottleOutPacketType.Land);
+             */
+        }
+
+        /// <summary>
+        /// Sets the throttles from values supplied by the client
+        /// </summary>
+        /// <param name="throttles"></param>
+        public void SetChildAgentThrottle(byte[] throttles)
+        {
+            SetChildAgentThrottle(throttles, 1.0f);
+        }
+
+        public void SetChildAgentThrottle(byte[] throttles,float factor)
+        {
+            m_udpClient.SetThrottles(throttles, factor);
+            GenericCall2 handler = OnUpdateThrottles;
+            if (handler != null)
+            {
+                handler();
+            }
+        }
+
+        /// <summary>
+        /// Sets the throttles from values supplied caller
+        /// </summary>
+        /// <param name="throttles"></param>
+        public void SetAgentThrottleSilent(int throttle, int setting)
+        {
+            m_udpClient.ForceThrottleSetting(throttle,setting);
+        }
+
+        public int GetAgentThrottleSilent(int throttle)
+        {
+            return m_udpClient.GetThrottleSetting(throttle);
+        }
+
+        /// <summary>
+        /// Get the current throttles for this client as a packed byte array
+        /// </summary>
+        /// <param name="multiplier">Unused</param>
+        /// <returns></returns>
+        public byte[] GetThrottlesPacked(float multiplier)
+        {
+            return m_udpClient.GetThrottlesPacked(multiplier);
+        }
+
+        /// <summary>
+        /// Cruft?
+        /// </summary>
+        public virtual void InPacket(object NewPack)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// This is the starting point for sending a simulator packet out to the client
+        /// </summary>
+        /// <param name="packet">Packet to send</param>
+        /// <param name="throttlePacketType">Throttling category for the packet</param>
+        protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType)
+        {
+            #region BinaryStats
+            LLUDPServer.LogPacketHeader(false, m_circuitCode, 0, packet.Type, (ushort)packet.Length);
+            #endregion BinaryStats
+
+            OutPacket(packet, throttlePacketType, true);
+        }
+
+        /// <summary>
+        /// This is the starting point for sending a simulator packet out to the client
+        /// </summary>
+        /// <param name="packet">Packet to send</param>
+        /// <param name="throttlePacketType">Throttling category for the packet</param>
+        /// <param name="doAutomaticSplitting">True to automatically split oversized
+        /// packets (the default), or false to disable splitting if the calling code
+        /// handles splitting manually</param>
+        protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType, bool doAutomaticSplitting)
+        {
+            OutPacket(packet, throttlePacketType, doAutomaticSplitting, null);
+        }
+
+        /// <summary>
+        /// This is the starting point for sending a simulator packet out to the client
+        /// </summary>
+        /// <param name="packet">Packet to send</param>
+        /// <param name="throttlePacketType">Throttling category for the packet</param>
+        /// <param name="doAutomaticSplitting">True to automatically split oversized
+        /// packets (the default), or false to disable splitting if the calling code
+        /// handles splitting manually</param>
+        /// <param name="method">The method to be called in the event this packet is reliable
+        /// and unacknowledged. The server will provide normal resend capability if you do not
+        /// provide your own method.</param>
+        protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType, bool doAutomaticSplitting, UnackedPacketMethod method)
+        {
+
+/* this is causing packet loss for some reason
+            if(!m_udpClient.IsConnected)
+            {
+                PacketPool.Instance.ReturnPacket(packet);
+                return;
+            }
+*/
+            if (m_outPacketsToDrop != null)
+            {
+                if (m_outPacketsToDrop.Contains(packet.Type.ToString()))
+                {
+                    PacketPool.Instance.ReturnPacket(packet);
+                    return;
+                }
+            }
+
+            if (DebugPacketLevel > 0)
+            {
+                bool logPacket = true;
+
+                if (DebugPacketLevel <= 255
+                    && (packet.Type == PacketType.SimStats || packet.Type == PacketType.SimulatorViewerTimeMessage))
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 200
+                    && (packet.Type == PacketType.ImagePacket
+                        || packet.Type == PacketType.ImageData
+                        || packet.Type == PacketType.LayerData
+                        || packet.Type == PacketType.CoarseLocationUpdate))
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 100 && (packet.Type == PacketType.AvatarAnimation || packet.Type == PacketType.ViewerEffect))
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 50
+                    && (packet.Type == PacketType.ImprovedTerseObjectUpdate || packet.Type == PacketType.ObjectUpdate))
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 25 && packet.Type == PacketType.ObjectPropertiesFamily)
+                    logPacket = false;
+
+                if (logPacket)
+                    m_log.DebugFormat(
+                        "[CLIENT]: PACKET OUT to   {0} ({1}) in {2} - {3}",
+                        Name, SceneAgent.IsChildAgent ? "child" : "root ", m_scene.RegionInfo.RegionName, packet.Type);
+            }
+
+            m_udpServer.SendPacket(m_udpClient, packet, throttlePacketType, doAutomaticSplitting, method);
+        }
+
+        protected void HandleAutopilot(Object sender, string method, List<String> args)
+        {
+            float locx = 0;
+            float locy = 0;
+            float locz = 0;
+            uint regionX = 0;
+            uint regionY = 0;
+
+            Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out regionX, out regionY);
+            locx = (float)(Convert.ToDouble(args[0]) - (double)regionX);
+            locy = (float)(Convert.ToDouble(args[1]) - (double)regionY);
+            locz = Convert.ToSingle(args[2]);
+
+            Action<Vector3, bool, bool> handlerAutoPilotGo = OnAutoPilotGo;
+            if (handlerAutoPilotGo != null)
+                handlerAutoPilotGo(new Vector3(locx, locy, locz), false, false);
+        }
+
+        /// <summary>
+        /// Entryway from the client to the simulator.  All UDP packets from the client will end up here
+        /// </summary>
+        /// <param name="Pack">OpenMetaverse.packet</param>
+        public void ProcessInPacket(Packet packet)
+        {
+            if (m_inPacketsToDrop != null)
+                if (m_inPacketsToDrop.Contains(packet.Type.ToString()))
+                    return;
+
+            if (DebugPacketLevel > 0)
+            {
+                bool logPacket = true;
+
+                if (DebugPacketLevel <= 255 && packet.Type == PacketType.AgentUpdate)
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 200 && packet.Type == PacketType.RequestImage)
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 100 && (packet.Type == PacketType.ViewerEffect || packet.Type == PacketType.AgentAnimation))
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 25 && packet.Type == PacketType.RequestObjectPropertiesFamily)
+                    logPacket = false;
+
+                if (logPacket)
+                    m_log.DebugFormat(
+                        "[CLIENT]: PACKET IN  from {0} ({1}) in {2} - {3}",
+                        Name, SceneAgent.IsChildAgent ? "child" : "root ", Scene.Name, packet.Type);
+            }
+
+            if (!ProcessPacketMethod(packet))
+                m_log.WarnFormat(
+                    "[CLIENT]: Unhandled packet {0} from {1} ({2}) in {3}.  Ignoring.",
+                    packet.Type, Name, SceneAgent.IsChildAgent ? "child" : "root ", Scene.Name);
+        }
+
+        private static PrimitiveBaseShape GetShapeFromAddPacket(ObjectAddPacket addPacket)
+        {
+            PrimitiveBaseShape shape = new PrimitiveBaseShape();
+
+            shape.PCode = addPacket.ObjectData.PCode;
+            shape.State = addPacket.ObjectData.State;
+            shape.LastAttachPoint = addPacket.ObjectData.State;
+            shape.PathBegin = addPacket.ObjectData.PathBegin;
+            shape.PathEnd = addPacket.ObjectData.PathEnd;
+            shape.PathScaleX = addPacket.ObjectData.PathScaleX;
+            shape.PathScaleY = addPacket.ObjectData.PathScaleY;
+            shape.PathShearX = addPacket.ObjectData.PathShearX;
+            shape.PathShearY = addPacket.ObjectData.PathShearY;
+            shape.PathSkew = addPacket.ObjectData.PathSkew;
+            shape.ProfileBegin = addPacket.ObjectData.ProfileBegin;
+            shape.ProfileEnd = addPacket.ObjectData.ProfileEnd;
+            shape.Scale = addPacket.ObjectData.Scale;
+            shape.PathCurve = addPacket.ObjectData.PathCurve;
+            shape.ProfileCurve = addPacket.ObjectData.ProfileCurve;
+            shape.ProfileHollow = addPacket.ObjectData.ProfileHollow;
+            shape.PathRadiusOffset = addPacket.ObjectData.PathRadiusOffset;
+            shape.PathRevolutions = addPacket.ObjectData.PathRevolutions;
+            shape.PathTaperX = addPacket.ObjectData.PathTaperX;
+            shape.PathTaperY = addPacket.ObjectData.PathTaperY;
+            shape.PathTwist = addPacket.ObjectData.PathTwist;
+            shape.PathTwistBegin = addPacket.ObjectData.PathTwistBegin;
+            Primitive.TextureEntry ntex = new Primitive.TextureEntry(new UUID("89556747-24cb-43ed-920b-47caed15465f"));
+            shape.TextureEntry = ntex.GetBytes();
+            //shape.Textures = ntex;
+            return shape;
+        }
+
+        public ClientInfo GetClientInfo()
+        {
+            ClientInfo info = m_udpClient.GetClientInfo();
+
+            info.proxyEP = null;
+            if (info.agentcircuit == null)
+                info.agentcircuit = RequestClientInfo();
+
+            return info;
+        }
+
+        public void SetClientInfo(ClientInfo info)
+        {
+            m_udpClient.SetClientInfo(info);
+        }
+
+        #region Media Parcel Members
+
+        public void SendParcelMediaCommand(uint flags, ParcelMediaCommandEnum command, float time)
+        {
+            ParcelMediaCommandMessagePacket commandMessagePacket = new ParcelMediaCommandMessagePacket();
+            commandMessagePacket.CommandBlock.Flags = flags;
+            commandMessagePacket.CommandBlock.Command = (uint)command;
+            commandMessagePacket.CommandBlock.Time = time;
+
+            OutPacket(commandMessagePacket, ThrottleOutPacketType.Task);
+        }
+
+        public void SendParcelMediaUpdate(string mediaUrl, UUID mediaTextureID,
+                                   byte autoScale, string mediaType, string mediaDesc, int mediaWidth, int mediaHeight,
+                                   byte mediaLoop)
+        {
+            ParcelMediaUpdatePacket updatePacket = new ParcelMediaUpdatePacket();
+            updatePacket.DataBlock.MediaURL = Util.StringToBytes256(mediaUrl);
+            updatePacket.DataBlock.MediaID = mediaTextureID;
+            updatePacket.DataBlock.MediaAutoScale = autoScale;
+
+            updatePacket.DataBlockExtended.MediaType = Util.StringToBytes256(mediaType);
+            updatePacket.DataBlockExtended.MediaDesc = Util.StringToBytes256(mediaDesc);
+            updatePacket.DataBlockExtended.MediaWidth = mediaWidth;
+            updatePacket.DataBlockExtended.MediaHeight = mediaHeight;
+            updatePacket.DataBlockExtended.MediaLoop = mediaLoop;
+
+            OutPacket(updatePacket, ThrottleOutPacketType.Task);
+        }
+
+        #endregion
+
+        #region Camera
+
+        public void SendSetFollowCamProperties(UUID objectID, SortedDictionary<int, float> parameters)
+        {
+            SetFollowCamPropertiesPacket packet = (SetFollowCamPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.SetFollowCamProperties);
+            packet.ObjectData.ObjectID = objectID;
+            SetFollowCamPropertiesPacket.CameraPropertyBlock[] camPropBlock = new SetFollowCamPropertiesPacket.CameraPropertyBlock[parameters.Count];
+            uint idx = 0;
+            foreach (KeyValuePair<int, float> pair in parameters)
+            {
+                SetFollowCamPropertiesPacket.CameraPropertyBlock block = new SetFollowCamPropertiesPacket.CameraPropertyBlock();
+                block.Type = pair.Key;
+                block.Value = pair.Value;
+
+                camPropBlock[idx++] = block;
+            }
+            packet.CameraProperty = camPropBlock;
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendClearFollowCamProperties(UUID objectID)
+        {
+            ClearFollowCamPropertiesPacket packet = (ClearFollowCamPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ClearFollowCamProperties);
+            packet.ObjectData.ObjectID = objectID;
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        #endregion
+
+        public void SetClientOption(string option, string value)
+        {
+            switch (option)
+            {
+                default:
+                    break;
+            }
+        }
+
+        public string GetClientOption(string option)
+        {
+            switch (option)
+            {
+                default:
+                    break;
+            }
+            return string.Empty;
+        }
+
+        #region IClientCore
+
+        private readonly Dictionary<Type, object> m_clientInterfaces = new Dictionary<Type, object>();
+
+        /// <summary>
+        /// Register an interface on this client, should only be called in the constructor.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="iface"></param>
+        protected void RegisterInterface<T>(T iface)
+        {
+            lock (m_clientInterfaces)
+            {
+                if (!m_clientInterfaces.ContainsKey(typeof(T)))
+                {
+                    m_clientInterfaces.Add(typeof(T), iface);
+                }
+            }
+        }
+
+        public bool TryGet<T>(out T iface)
+        {
+            if (m_clientInterfaces.ContainsKey(typeof(T)))
+            {
+                iface = (T)m_clientInterfaces[typeof(T)];
+                return true;
+            }
+            iface = default(T);
+            return false;
+        }
+
+        public T Get<T>()
+        {
+            return (T)m_clientInterfaces[typeof(T)];
+        }
+
+        public void Disconnect(string reason)
+        {
+            Kick(reason);
+            Thread.Sleep(1000);
+            Disconnect();
+        }
+
+        public void Disconnect()
+        {
+            Close();
+        }
+
+        #endregion
+
+        public void RefreshGroupMembership()
+        {
+            lock(m_groupPowers)
+            {
+                GroupMembershipData activeMembership = null;
+                if (m_GroupsModule != null)
+                {
+                    GroupMembershipData[] GroupMembership =
+                        m_GroupsModule.GetMembershipData(AgentId);
+
+                    m_groupPowers.Clear();
+
+                    if (GroupMembership != null)
+                    {
+                        for (int i = 0; i < GroupMembership.Length; i++)
+                        {
+                            m_groupPowers[GroupMembership[i].GroupID] = GroupMembership[i].GroupPowers;
+                        }
+                    }
+
+                    activeMembership = m_GroupsModule.GetActiveMembershipData(AgentId);
+                    if(activeMembership != null)
+                    {
+                        if(!m_groupPowers.ContainsKey(activeMembership.GroupID))
+                            activeMembership = null;
+                        else
+                        {
+                            m_activeGroupID = activeMembership.GroupID;
+                            m_activeGroupName = activeMembership.GroupName;
+                            m_activeGroupPowers = ActiveGroupPowers;
+                        }
+                    }
+                }
+
+                if(activeMembership == null)
+                {
+                    m_activeGroupID = UUID.Zero;
+                    m_activeGroupName = "";
+                    m_activeGroupPowers = 0;
+                }
+            }
+        }
+
+        public void UpdateGroupMembership(GroupMembershipData[] data)
+        {
+            lock(m_groupPowers)
+            {
+                m_groupPowers.Clear();
+
+                if (data != null)
+                {
+                    for (int i = 0; i < data.Length; i++)
+                        m_groupPowers[data[i].GroupID] = data[i].GroupPowers;
+                }
+            }
+        }
+
+        public void GroupMembershipRemove(UUID GroupID)
+        {
+            lock(m_groupPowers)
+            {
+                if(m_groupPowers.ContainsKey(GroupID))
+                    m_groupPowers.Remove(GroupID);
+            }
+        }
+
+        public void GroupMembershipAddReplace(UUID GroupID,ulong GroupPowers)
+        {
+            lock(m_groupPowers)
+            {
+                m_groupPowers[GroupID] = GroupPowers;
+            }
+        }
+
+        public string Report()
+        {
+            return m_udpClient.GetStats();
+        }
+
+        public string XReport(string uptime, string version)
+        {
+            return String.Empty;
+        }
+
+        public OSDMap OReport(string uptime, string version)
+        {
+            return new OSDMap();
+        }
+
+        /// <summary>
+        /// Make an asset request to the asset service in response to a client request.
+        /// </summary>
+        /// <param name="transferRequest"></param>
+        /// <param name="taskID"></param>
+        protected void MakeAssetRequest(TransferRequestPacket transferRequest, UUID taskID)
+        {
+            UUID requestID = UUID.Zero;
+            int sourceType = transferRequest.TransferInfo.SourceType;
+
+            if (sourceType == (int)SourceType.Asset)
+            {
+                requestID = new UUID(transferRequest.TransferInfo.Params, 0);
+            }
+            else if (sourceType == (int)SourceType.SimInventoryItem)
+            {
+                requestID = new UUID(transferRequest.TransferInfo.Params, 80);
+            }
+            else if (sourceType == (int)SourceType.SimEstate)
+            {
+                requestID = taskID;
+            }
+
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Received transfer request for {0} in {1} type {2} by {3}",
+//                requestID, taskID, (SourceType)sourceType, Name);
+
+
+            //Note, the bool returned from the below function is useless since it is always false.
+            m_assetService.Get(requestID.ToString(), transferRequest, AssetReceived);
+
+        }
+
+        /// <summary>
+        /// When we get a reply back from the asset service in response to a client request, send back the data.
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="sender"></param>
+        /// <param name="asset"></param>
+        protected void AssetReceived(string id, Object sender, AssetBase asset)
+        {
+            TransferRequestPacket transferRequest = (TransferRequestPacket)sender;
+
+            UUID requestID = UUID.Zero;
+            byte source = (byte)SourceType.Asset;
+
+            AssetRequestToClient req = new AssetRequestToClient();
+
+            if (asset == null)
+            {
+                // Try the user's asset server
+                IInventoryAccessModule inventoryAccessModule = Scene.RequestModuleInterface<IInventoryAccessModule>();
+
+                string assetServerURL = string.Empty;
+                if (inventoryAccessModule.IsForeignUser(AgentId, out assetServerURL) && !string.IsNullOrEmpty(assetServerURL))
+                {
+                    if (!assetServerURL.EndsWith("/") && !assetServerURL.EndsWith("="))
+                        assetServerURL = assetServerURL + "/";
+
+                    //m_log.DebugFormat("[LLCLIENTVIEW]: asset {0} not found in local storage. Trying user's storage.", assetServerURL + id);
+                    asset = m_scene.AssetService.Get(assetServerURL + id);
+                }
+
+                if (asset == null)
+                {
+                    req.AssetInf = null;
+                    req.AssetRequestSource = source;
+                    req.IsTextureRequest = false;
+                    req.NumPackets = 0;
+                    req.Params = transferRequest.TransferInfo.Params;
+                    req.RequestAssetID = requestID;
+                    req.TransferRequestID = transferRequest.TransferInfo.TransferID;
+
+                    SendAssetNotFound(req);
+                    return;
+                }
+            }
+
+            if (transferRequest.TransferInfo.SourceType == (int)SourceType.Asset)
+            {
+                requestID = new UUID(transferRequest.TransferInfo.Params, 0);
+            }
+            else if (transferRequest.TransferInfo.SourceType == (int)SourceType.SimInventoryItem)
+            {
+                requestID = new UUID(transferRequest.TransferInfo.Params, 80);
+                source = (byte)SourceType.SimInventoryItem;
+                //m_log.Debug("asset request " + requestID);
+            }
+
+            // Scripts cannot be retrieved by direct request
+            if (transferRequest.TransferInfo.SourceType == (int)SourceType.Asset && asset.Type == 10)
+                return;
+
+            // The asset is known to exist and is in our cache, so add it to the AssetRequests list
+            req.AssetInf = asset;
+            req.AssetRequestSource = source;
+            req.IsTextureRequest = false;
+            req.NumPackets = CalculateNumPackets(asset.Data);
+            req.Params = transferRequest.TransferInfo.Params;
+            req.RequestAssetID = requestID;
+            req.TransferRequestID = transferRequest.TransferInfo.TransferID;
+
+            SendAsset(req);
+        }
+
+        /// <summary>
+        /// Calculate the number of packets required to send the asset to the client.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        private static int CalculateNumPackets(byte[] data)
+        {
+//            const uint m_maxPacketSize = 600;
+            uint m_maxPacketSize = MaxTransferBytesPerPacket;
+            int numPackets = 1;
+
+            if (data == null)
+                return 0;
+
+            if (data.LongLength > m_maxPacketSize)
+            {
+                // over max number of bytes so split up file
+                long restData = data.LongLength - m_maxPacketSize;
+                int restPackets = (int)((restData + m_maxPacketSize - 1) / m_maxPacketSize);
+                numPackets += restPackets;
+            }
+
+            return numPackets;
+        }
+
+        public void SendRebakeAvatarTextures(UUID textureID)
+        {
+            RebakeAvatarTexturesPacket pack =
+                (RebakeAvatarTexturesPacket)PacketPool.Instance.GetPacket(PacketType.RebakeAvatarTextures);
+
+            pack.TextureData = new RebakeAvatarTexturesPacket.TextureDataBlock();
+            pack.TextureData.TextureID = textureID;
+            OutPacket(pack, ThrottleOutPacketType.Task);
+        }
+
+        public struct PacketProcessor
+        {
+            /// <summary>
+            /// Packet handling method.
+            /// </summary>
+            public PacketMethod method { get; set; }
+
+            /// <summary>
+            /// Should this packet be handled asynchronously?
+            /// </summary>
+            public bool Async { get; set; }
+
+        }
+
+        public class AsyncPacketProcess
+        {
+            public bool result = false;
+            public readonly LLClientView ClientView = null;
+            public readonly Packet Pack = null;
+            public readonly PacketMethod Method = null;
+            public AsyncPacketProcess(LLClientView pClientview, PacketMethod pMethod, Packet pPack)
+            {
+                ClientView = pClientview;
+                Method = pMethod;
+                Pack = pPack;
+            }
+        }
+
+        public static OSD BuildEvent(string eventName, OSD eventBody)
+        {
+            OSDMap osdEvent = new OSDMap(2);
+            osdEvent.Add("message", new OSDString(eventName));
+            osdEvent.Add("body", eventBody);
+
+            return osdEvent;
+        }
+
+        public void SendAvatarInterestsReply(UUID avatarID, uint wantMask, string wantText, uint skillsMask, string skillsText, string languages)
+        {
+            AvatarInterestsReplyPacket packet = (AvatarInterestsReplyPacket)PacketPool.Instance.GetPacket(PacketType.AvatarInterestsReply);
+
+            packet.AgentData = new AvatarInterestsReplyPacket.AgentDataBlock();
+            packet.AgentData.AgentID = AgentId;
+            packet.AgentData.AvatarID = avatarID;
+
+            packet.PropertiesData = new AvatarInterestsReplyPacket.PropertiesDataBlock();
+            packet.PropertiesData.WantToMask = wantMask;
+            packet.PropertiesData.WantToText = Utils.StringToBytes(wantText);
+            packet.PropertiesData.SkillsMask = skillsMask;
+            packet.PropertiesData.SkillsText = Utils.StringToBytes(skillsText);
+            packet.PropertiesData.LanguagesText = Utils.StringToBytes(languages);
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendChangeUserRights(UUID agentID, UUID friendID, int rights)
+        {
+            ChangeUserRightsPacket packet = (ChangeUserRightsPacket)PacketPool.Instance.GetPacket(PacketType.ChangeUserRights);
+
+            packet.AgentData = new ChangeUserRightsPacket.AgentDataBlock();
+            packet.AgentData.AgentID = agentID;
+
+            packet.Rights = new ChangeUserRightsPacket.RightsBlock[1];
+            packet.Rights[0] = new ChangeUserRightsPacket.RightsBlock();
+            packet.Rights[0].AgentRelated = friendID;
+            packet.Rights[0].RelatedRights = rights;
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendTextBoxRequest(string message, int chatChannel, string objectname, UUID ownerID, string ownerFirstName, string ownerLastName, UUID objectId)
+        {
+            ScriptDialogPacket dialog = (ScriptDialogPacket)PacketPool.Instance.GetPacket(PacketType.ScriptDialog);
+            dialog.Data.ObjectID = objectId;
+            dialog.Data.ChatChannel = chatChannel;
+            dialog.Data.ImageID = UUID.Zero;
+            dialog.Data.ObjectName = Util.StringToBytes256(objectname);
+            // this is the username of the *owner*
+            dialog.Data.FirstName = Util.StringToBytes256(ownerFirstName);
+            dialog.Data.LastName = Util.StringToBytes256(ownerLastName);
+            dialog.Data.Message =  Util.StringToBytes(message,512);
+
+            ScriptDialogPacket.ButtonsBlock[] buttons = new ScriptDialogPacket.ButtonsBlock[1];
+            buttons[0] = new ScriptDialogPacket.ButtonsBlock();
+            buttons[0].ButtonLabel = Util.StringToBytes256("!!llTextBox!!");
+            dialog.Buttons = buttons;
+
+            dialog.OwnerData = new ScriptDialogPacket.OwnerDataBlock[1];
+            dialog.OwnerData[0] = new ScriptDialogPacket.OwnerDataBlock();
+            dialog.OwnerData[0].OwnerID = ownerID;
+
+            OutPacket(dialog, ThrottleOutPacketType.Task);
+        }
+
+        public void SendAgentTerseUpdate(ISceneEntity p)
+        {
+            if (p is ScenePresence)
+            {
+//                m_log.DebugFormat(
+//                    "[LLCLIENTVIEW]: Immediately sending terse agent update for {0} to {1} in {2}",
+//                    p.Name, Name, Scene.Name);
+
+                // It turns out to get the agent to stop flying, you have to feed it stop flying velocities
+                // There's no explicit message to send the client to tell it to stop flying..   it relies on the
+                // velocity, collision plane and avatar height
+
+                // Add 1/6 the avatar's height to it's position so it doesn't shoot into the air
+                // when the avatar stands up
+
+                ImprovedTerseObjectUpdatePacket.ObjectDataBlock block =
+                    CreateImprovedTerseBlock(p, false);
+
+//                const float TIME_DILATION = 1.0f;
+                ushort timeDilation = Utils.FloatToUInt16(m_scene.TimeDilation, 0.0f, 1.0f);;
+
+                ImprovedTerseObjectUpdatePacket packet
+                    = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(
+                        PacketType.ImprovedTerseObjectUpdate);
+
+                packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                packet.RegionData.TimeDilation = timeDilation;
+                packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[1];
+
+                packet.ObjectData[0] = block;
+
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
+            }
+
+            //ControllingClient.SendAvatarTerseUpdate(new SendAvatarTerseData(m_rootRegionHandle, (ushort)(m_scene.TimeDilation * ushort.MaxValue), LocalId,
+            //        AbsolutePosition, Velocity, Vector3.Zero, m_bodyRot, new Vector4(0,0,1,AbsolutePosition.Z - 0.5f), m_uuid, null, GetUpdatePriority(ControllingClient)));
+        }
+
+        public void SendPlacesReply(UUID queryID, UUID transactionID,
+                PlacesReplyData[] data)
+        {
+            PlacesReplyPacket reply = null;
+            PlacesReplyPacket.QueryDataBlock[] dataBlocks =
+                    new PlacesReplyPacket.QueryDataBlock[0];
+
+            for (int i = 0 ; i < data.Length ; i++)
+            {
+                PlacesReplyPacket.QueryDataBlock block =
+                        new PlacesReplyPacket.QueryDataBlock();
+
+                block.OwnerID = data[i].OwnerID;
+                block.Name = Util.StringToBytes256(data[i].Name);
+                block.Desc = Util.StringToBytes1024(data[i].Desc);
+                block.ActualArea = data[i].ActualArea;
+                block.BillableArea = data[i].BillableArea;
+                block.Flags = data[i].Flags;
+                block.GlobalX = data[i].GlobalX;
+                block.GlobalY = data[i].GlobalY;
+                block.GlobalZ = data[i].GlobalZ;
+                block.SimName = Util.StringToBytes256(data[i].SimName);
+                block.SnapshotID = data[i].SnapshotID;
+                block.Dwell = data[i].Dwell;
+                block.Price = data[i].Price;
+
+                if (reply != null && reply.Length + block.Length > 1400)
+                {
+                    OutPacket(reply, ThrottleOutPacketType.Task);
+
+                    reply = null;
+                    dataBlocks = new PlacesReplyPacket.QueryDataBlock[0];
+                }
+
+                if (reply == null)
+                {
+                    reply = (PlacesReplyPacket)PacketPool.Instance.GetPacket(PacketType.PlacesReply);
+                    reply.AgentData = new PlacesReplyPacket.AgentDataBlock();
+                    reply.AgentData.AgentID = AgentId;
+                    reply.AgentData.QueryID = queryID;
+
+                    reply.TransactionData = new PlacesReplyPacket.TransactionDataBlock();
+                    reply.TransactionData.TransactionID = transactionID;
+
+                    reply.QueryData = dataBlocks;
+                }
+
+                Array.Resize(ref dataBlocks, dataBlocks.Length + 1);
+                dataBlocks[dataBlocks.Length - 1] = block;
+                reply.QueryData = dataBlocks;
+            }
+            if (reply != null)
+                OutPacket(reply, ThrottleOutPacketType.Task);
+        }
+
+        public void SendRemoveInventoryItems(UUID[] items)
+        {
+            IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
+
+            if (eq == null)
+            {
+                m_log.DebugFormat("[LLCLIENT]: Null event queue");
+                return;
+            }
+
+            OSDMap llsd = new OSDMap(3);
+
+            OSDMap AgentDataMap = new OSDMap(1);
+            AgentDataMap.Add("AgentID", OSD.FromUUID(AgentId));
+            AgentDataMap.Add("SessionID", OSD.FromUUID(SessionId));
+
+            OSDArray AgentData = new OSDArray(1);
+            AgentData.Add(AgentDataMap);
+
+            llsd.Add("AgentData", AgentData);
+
+            OSDArray ItemData = new OSDArray();
+
+            foreach (UUID item in items)
+            {
+                OSDMap ItemDataMap = new OSDMap(2);
+                ItemDataMap.Add("ItemID", OSD.FromUUID(item));
+                ItemDataMap.Add("AgentID", OSD.FromUUID(AgentId));
+
+                ItemData.Add(ItemDataMap);
+            }
+
+            llsd.Add("InventoryData", ItemData);
+
+            eq.Enqueue(BuildEvent("RemoveInventoryItem",
+                    llsd), AgentId);
+        }
+
+        public void SendRemoveInventoryFolders(UUID[] folders)
+        {
+            IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
+
+            if (eq == null)
+            {
+                m_log.DebugFormat("[LLCLIENT]: Null event queue");
+                return;
+            }
+
+            OSDMap llsd = new OSDMap(3);
+
+            OSDMap AgentDataMap = new OSDMap(1);
+            AgentDataMap.Add("AgentID", OSD.FromUUID(AgentId));
+            AgentDataMap.Add("SessionID", OSD.FromUUID(SessionId));
+
+            OSDArray AgentData = new OSDArray(1);
+            AgentData.Add(AgentDataMap);
+
+            llsd.Add("AgentData", AgentData);
+
+            OSDArray FolderData = new OSDArray();
+
+            foreach (UUID folder in folders)
+            {
+                OSDMap FolderDataMap = new OSDMap(2);
+                FolderDataMap.Add("FolderID", OSD.FromUUID(folder));
+                FolderDataMap.Add("AgentID", OSD.FromUUID(AgentId));
+
+                FolderData.Add(FolderDataMap);
+            }
+
+            llsd.Add("FolderData", FolderData);
+
+            eq.Enqueue(BuildEvent("RemoveInventoryFolder",
+                    llsd), AgentId);
+        }
+
+        private byte[] EncodeU32(uint val)
+        {
+            byte[] ret = BitConverter.GetBytes(val);
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(ret);
+            return ret;
+        }
+
+        public void SendBulkUpdateInventory(InventoryFolderBase[] folders, InventoryItemBase[] items)
+        {
+            IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
+
+            if (eq == null)
+            {
+                m_log.DebugFormat("[LLCLIENT]: Null event queue");
+                return;
+            }
+
+            OSDMap llsd = new OSDMap(3);
+
+            OSDMap AgentDataMap = new OSDMap(1);
+            AgentDataMap.Add("AgentID", OSD.FromUUID(AgentId));
+            AgentDataMap.Add("SessionID", OSD.FromUUID(SessionId));
+            AgentDataMap.Add("TransactionID", OSD.FromUUID(UUID.Random()));
+
+            OSDArray AgentData = new OSDArray(1);
+            AgentData.Add(AgentDataMap);
+
+            llsd.Add("AgentData", AgentData);
+
+            OSDArray FolderData = new OSDArray();
+
+            foreach (InventoryFolderBase folder in folders)
+            {
+                OSDMap FolderDataMap = new OSDMap(5);
+                FolderDataMap.Add("FolderID", OSD.FromUUID(folder.ID));
+                FolderDataMap.Add("AgentID", OSD.FromUUID(AgentId));
+                FolderDataMap.Add("ParentID", OSD.FromUUID(folder.ParentID));
+                FolderDataMap.Add("Type", OSD.FromInteger(folder.Type));
+                FolderDataMap.Add("Name", OSD.FromString(folder.Name));
+
+                FolderData.Add(FolderDataMap);
+            }
+
+            llsd.Add("FolderData", FolderData);
+
+            OSDArray ItemData = new OSDArray();
+
+            foreach (InventoryItemBase item in items)
+            {
+                OSDMap ItemDataMap = new OSDMap();
+
+                ItemDataMap.Add("ItemID", OSD.FromUUID(item.ID));
+                ItemDataMap.Add("FolderID", OSD.FromUUID(item.Folder));
+
+                ItemDataMap.Add("CreatorID", OSD.FromUUID(item.CreatorIdAsUuid));
+                ItemDataMap.Add("OwnerID", OSD.FromUUID(item.Owner));
+                ItemDataMap.Add("GroupID", OSD.FromUUID(item.GroupID));
+                ItemDataMap.Add("BaseMask", OSD.FromBinary(EncodeU32((uint)item.BasePermissions)));
+                ItemDataMap.Add("OwnerMask", OSD.FromBinary(EncodeU32((uint)item.CurrentPermissions)));
+                ItemDataMap.Add("GroupMask", OSD.FromBinary(EncodeU32((uint)item.GroupPermissions)));
+                ItemDataMap.Add("EveryoneMask", OSD.FromBinary(EncodeU32((uint)item.EveryOnePermissions)));
+                ItemDataMap.Add("NextOwnerMask", OSD.FromBinary(EncodeU32((uint)item.NextPermissions)));
+                ItemDataMap.Add("GroupOwned", OSD.FromBoolean(item.GroupOwned));
+                ItemDataMap.Add("AssetID", OSD.FromUUID(item.AssetID));
+                ItemDataMap.Add("Type", OSD.FromInteger(item.AssetType));
+                ItemDataMap.Add("InvType", OSD.FromInteger(item.InvType));
+                ItemDataMap.Add("Flags", OSD.FromBinary(EncodeU32((uint)item.Flags)));
+                ItemDataMap.Add("SaleType", OSD.FromInteger((byte)item.SaleType));
+                ItemDataMap.Add("SalePrice", OSD.FromInteger(item.SalePrice));
+                ItemDataMap.Add("Name", OSD.FromString(item.Name));
+                ItemDataMap.Add("Description", OSD.FromString(item.Description));
+                ItemDataMap.Add("CreationDate", OSD.FromInteger(item.CreationDate));
+
+                ItemDataMap.Add("CRC", OSD.FromBinary(EncodeU32(
+                        Helpers.InventoryCRC(1000, 0, (sbyte)item.InvType,
+                        (sbyte)item.AssetType, item.AssetID,
+                        item.GroupID, 100,
+                        item.Owner, item.CreatorIdAsUuid,
+                        item.ID, item.Folder,
+                        (uint)PermissionMask.All, 1, (uint)PermissionMask.All, (uint)PermissionMask.All,
+                        (uint)PermissionMask.All)
+                )));
+                ItemDataMap.Add("CallbackID", 0);
+
+                ItemData.Add(ItemDataMap);
+            }
+
+            llsd.Add("ItemData", ItemData);
+
+            eq.Enqueue(BuildEvent("BulkUpdateInventory",
+                    llsd), AgentId);
+        }
+
+        private HashSet<string> m_outPacketsToDrop;
+
+        public bool AddOutPacketToDropSet(string packetName)
+        {
+            if (m_outPacketsToDrop == null)
+                m_outPacketsToDrop = new HashSet<string>();
+
+            return m_outPacketsToDrop.Add(packetName);
+        }
+
+        public bool RemoveOutPacketFromDropSet(string packetName)
+        {
+            if (m_outPacketsToDrop == null)
+                return false;
+
+            return m_outPacketsToDrop.Remove(packetName);
+        }
+
+        public HashSet<string> GetOutPacketDropSet()
+        {
+            return new HashSet<string>(m_outPacketsToDrop);
+        }
+
+        private HashSet<string> m_inPacketsToDrop;
+
+        public bool AddInPacketToDropSet(string packetName)
+        {
+            if (m_inPacketsToDrop == null)
+                m_inPacketsToDrop = new HashSet<string>();
+
+            return m_inPacketsToDrop.Add(packetName);
+        }
+
+        public bool RemoveInPacketFromDropSet(string packetName)
+        {
+            if (m_inPacketsToDrop == null)
+                return false;
+
+            return m_inPacketsToDrop.Remove(packetName);
+        }
+
+        public HashSet<string> GetInPacketDropSet()
+        {
+            return new HashSet<string>(m_inPacketsToDrop);
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs
new file mode 100644
index 0000000..deefd40
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs
@@ -0,0 +1,360 @@
+/*
+ * 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.Threading;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenMetaverse;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+using log4net;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    /// <summary>
+    /// This class handles UDP texture requests.
+    /// </summary>
+    public class LLImageManager
+    {
+        private sealed class J2KImageComparer : IComparer<J2KImage>
+        {
+            public int Compare(J2KImage x, J2KImage y)
+            {
+                return x.Priority.CompareTo(y.Priority);
+            }
+        }
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private bool m_shuttingdown;
+        private AssetBase m_missingImage;
+        private IAssetService m_assetCache;
+        private IJ2KDecoder m_j2kDecodeModule;
+
+        /// <summary>
+        /// Priority queue for determining which image to send first.
+        /// </summary>
+        private C5.IntervalHeap<J2KImage> m_priorityQueue = new C5.IntervalHeap<J2KImage>(10, new J2KImageComparer());
+
+        /// <summary>
+        /// Used to control thread access to the priority queue.
+        /// </summary>
+        private object m_syncRoot = new object();
+
+        /// <summary>
+        /// Client served by this image manager
+        /// </summary>
+        public IClientAPI Client { get; private set; }
+
+        public AssetBase MissingImage { get { return m_missingImage; } }
+
+        public LLImageManager(IClientAPI client, IAssetService pAssetCache, IJ2KDecoder pJ2kDecodeModule)
+        {
+            Client = client;
+            m_assetCache = pAssetCache;
+
+            if (pAssetCache != null)
+                m_missingImage = pAssetCache.Get("5748decc-f629-461c-9a36-a35a221fe21f");
+
+            if (m_missingImage == null)
+                m_log.Error("[ClientView] - Couldn't set missing image asset, falling back to missing image packet. This is known to crash the client");
+
+            m_j2kDecodeModule = pJ2kDecodeModule;
+        }
+
+        /// <summary>
+        /// Handles an incoming texture request or update to an existing texture request
+        /// </summary>
+        /// <param name="newRequest"></param>
+        public void EnqueueReq(TextureRequestArgs newRequest)
+        {
+            if (!m_shuttingdown)
+            {
+                J2KImage imgrequest;
+
+                // Do a linear search for this texture download
+                lock (m_syncRoot)
+                    m_priorityQueue.Find(delegate(J2KImage img) { return img.TextureID == newRequest.RequestedAssetID; }, out imgrequest);
+
+                if (imgrequest != null)
+                {
+                    if (newRequest.DiscardLevel == -1 && newRequest.Priority == 0f)
+                    {
+                        //m_log.Debug("[TEX]: (CAN) ID=" + newRequest.RequestedAssetID);
+
+                        try
+                        {
+                            lock (m_syncRoot)
+                                m_priorityQueue.Delete(imgrequest.PriorityQueueHandle);
+                        }
+                        catch (Exception) { }
+                    }
+                    else
+                    {
+//                        m_log.DebugFormat(
+//                            "[LL IMAGE MANAGER]: Received duplicate of existing request for {0}, start packet {1} from {2}",
+//                            newRequest.RequestedAssetID, newRequest.PacketNumber, m_client.Name);
+
+//                        m_log.DebugFormat("[TEX]: (UPD) ID={0}: D={1}, S={2}, P={3}",
+//                            newRequest.RequestedAssetID, newRequest.DiscardLevel, newRequest.PacketNumber, newRequest.Priority);
+
+                        //Check the packet sequence to make sure this isn't older than
+                        //one we've already received
+                        if (newRequest.requestSequence > imgrequest.LastSequence)
+                        {
+                            //Update the sequence number of the last RequestImage packet
+                            imgrequest.LastSequence = newRequest.requestSequence;
+
+                            //Update the requested discard level
+                            imgrequest.DiscardLevel = newRequest.DiscardLevel;
+
+                            //Update the requested packet number
+                            imgrequest.StartPacket = Math.Max(1, newRequest.PacketNumber);
+
+                            //Update the requested priority
+                            imgrequest.Priority = newRequest.Priority;
+
+                            UpdateImageInQueue(imgrequest);
+
+                            imgrequest.RunUpdate();
+
+//                        J2KImage imgrequest2 = new J2KImage(this);
+//                        imgrequest2.J2KDecoder = m_j2kDecodeModule;
+//                        imgrequest2.AssetService = m_assetCache;
+//                        imgrequest2.AgentID = m_client.AgentId;
+//                        imgrequest2.InventoryAccessModule = m_client.Scene.RequestModuleInterface<IInventoryAccessModule>();
+//                        imgrequest2.DiscardLevel = newRequest.DiscardLevel;
+//                        imgrequest2.StartPacket = Math.Max(1, newRequest.PacketNumber);
+//                        imgrequest2.Priority = newRequest.Priority;
+//                        imgrequest2.TextureID = newRequest.RequestedAssetID;
+//                        imgrequest2.Priority = newRequest.Priority;
+//
+//                        //Add this download to the priority queue
+//                        AddImageToQueue(imgrequest2);
+//
+//                        imgrequest2.RunUpdate();
+
+                        }
+//                        else
+//                        {
+//                            m_log.DebugFormat(
+//                                "[LL IMAGE MANAGER]: Ignoring duplicate of existing request for {0} (sequence {1}) from {2} as its request sequence {3} is not greater",
+//                                newRequest.RequestedAssetID, imgrequest.LastSequence, m_client.Name, newRequest.requestSequence);
+//                        }
+                    }
+                }
+                else
+                {
+                    if (newRequest.DiscardLevel == -1 && newRequest.Priority == 0f)
+                    {
+                        //m_log.DebugFormat("[TEX]: (IGN) ID={0}: D={1}, S={2}, P={3}",
+                        //    newRequest.RequestedAssetID, newRequest.DiscardLevel, newRequest.PacketNumber, newRequest.Priority);
+                    }
+                    else
+                    {
+//                        m_log.DebugFormat(
+//                            "[LL IMAGE MANAGER]: Received request for {0}, start packet {1} from {2}",
+//                            newRequest.RequestedAssetID, newRequest.PacketNumber, m_client.Name);
+
+                        //m_log.DebugFormat("[TEX]: (NEW) ID={0}: D={1}, S={2}, P={3}",
+                        //    newRequest.RequestedAssetID, newRequest.DiscardLevel, newRequest.PacketNumber, newRequest.Priority);
+
+                        imgrequest = new J2KImage(this);
+                        imgrequest.J2KDecoder = m_j2kDecodeModule;
+                        imgrequest.AssetService = m_assetCache;
+                        imgrequest.AgentID = Client.AgentId;
+                        imgrequest.InventoryAccessModule = Client.Scene.RequestModuleInterface<IInventoryAccessModule>();
+                        imgrequest.DiscardLevel = newRequest.DiscardLevel;
+                        imgrequest.StartPacket = Math.Max(1, newRequest.PacketNumber);
+                        imgrequest.Priority = newRequest.Priority;
+                        imgrequest.TextureID = newRequest.RequestedAssetID;
+                        imgrequest.Priority = newRequest.Priority;
+
+                        //Add this download to the priority queue
+                        AddImageToQueue(imgrequest);
+
+                        imgrequest.RunUpdate();
+                    }
+                }
+            }
+        }
+
+        public bool HasUpdates()
+        {
+            J2KImage image = GetHighestPriorityImage();
+
+            return image != null && image.IsDecoded;
+        }
+
+        public bool ProcessImageQueue(int packetsToSend)
+        {
+            int packetsSent = 0;
+
+            while (packetsSent < packetsToSend)
+            {
+                J2KImage image = GetHighestPriorityImage();
+
+                // If null was returned, the texture priority queue is currently empty
+                if (image == null)
+                    break;
+
+                if (image.IsDecoded)
+                {
+                    int sent;
+                    bool imageDone = image.SendPackets(Client, packetsToSend - packetsSent, out sent);
+                    packetsSent += sent;
+
+                    // If the send is complete, destroy any knowledge of this transfer
+                    if (imageDone)
+                        RemoveImageFromQueue(image);
+                }
+                else
+                {
+                    // TODO: This is a limitation of how LLImageManager is currently
+                    // written. Undecoded textures should not be going into the priority
+                    // queue, because a high priority undecoded texture will clog up the
+                    // pipeline for a client
+//                    m_log.DebugFormat(
+//                        "[LL IMAGE MANAGER]: Exiting image queue processing early on encountering undecoded image {0}",
+//                        image.TextureID);
+
+                    break;
+                }
+            }
+
+//            if (packetsSent != 0)
+//                m_log.DebugFormat("[LL IMAGE MANAGER]: Processed {0} packets from image queue", packetsSent);
+
+            return m_priorityQueue.Count > 0;
+        }
+
+        /// <summary>
+        /// Faux destructor
+        /// </summary>
+        public void Close()
+        {
+            m_shuttingdown = true;
+        }
+
+        /// <summary>
+        /// Clear the image queue.
+        /// </summary>
+        /// <returns>The number of requests cleared.</returns>
+        public int ClearImageQueue()
+        {
+            int requestsDeleted;
+
+            lock (m_priorityQueue)
+            {
+                requestsDeleted = m_priorityQueue.Count;
+
+                // Surprisingly, there doesn't seem to be a clear method at this time.
+                while (!m_priorityQueue.IsEmpty)
+                    m_priorityQueue.DeleteMax();
+            }
+
+            return requestsDeleted;
+        }
+
+        /// <summary>
+        /// Returns an array containing all the images in the queue.
+        /// </summary>
+        /// <returns></returns>
+        public J2KImage[] GetImages()
+        {
+            lock (m_priorityQueue)
+                return m_priorityQueue.ToArray();
+        }
+
+        #region Priority Queue Helpers
+
+        private J2KImage GetHighestPriorityImage()
+        {
+            J2KImage image = null;
+
+            lock (m_syncRoot)
+            {
+                if (m_priorityQueue.Count > 0)
+                {
+                    try
+                    {
+                        image = m_priorityQueue.FindMax();
+                    }
+                    catch (Exception) { }
+                }
+            }
+            return image;
+        }
+
+        private void AddImageToQueue(J2KImage image)
+        {
+            image.PriorityQueueHandle = null;
+
+            lock (m_syncRoot)
+            {
+                try
+                {
+                    m_priorityQueue.Add(ref image.PriorityQueueHandle, image);
+                }
+                catch (Exception) { }
+            }
+        }
+
+        private void RemoveImageFromQueue(J2KImage image)
+        {
+            lock (m_syncRoot)
+            {
+                try
+                {
+                    m_priorityQueue.Delete(image.PriorityQueueHandle);
+                }
+                catch (Exception) { }
+            }
+        }
+
+        private void UpdateImageInQueue(J2KImage image)
+        {
+            lock (m_syncRoot)
+            {
+                try
+                {
+                    m_priorityQueue.Replace(image.PriorityQueueHandle, image);
+                }
+                catch (Exception)
+                {
+                    image.PriorityQueueHandle = null;
+                    m_priorityQueue.Add(ref image.PriorityQueueHandle, image);
+                }
+            }
+        }
+
+        #endregion Priority Queue Helpers
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs
new file mode 100644
index 0000000..439621a
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs
@@ -0,0 +1,918 @@
+/*
+ * 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.Net;
+using System.Threading;
+using log4net;
+using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+
+using TokenBucket = OpenSim.Region.ClientStack.LindenUDP.TokenBucket;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    #region Delegates
+
+    /// <summary>
+    /// Fired when updated networking stats are produced for this client
+    /// </summary>
+    /// <param name="inPackets">Number of incoming packets received since this
+    /// event was last fired</param>
+    /// <param name="outPackets">Number of outgoing packets sent since this
+    /// event was last fired</param>
+    /// <param name="unAckedBytes">Current total number of bytes in packets we
+    /// are waiting on ACKs for</param>
+    public delegate void PacketStats(int inPackets, int outPackets, int unAckedBytes);
+    /// <summary>
+    /// Fired when the queue for one or more packet categories is empty. This
+    /// event can be hooked to put more data on the empty queues
+    /// </summary>
+    /// <param name="category">Categories of the packet queues that are empty</param>
+    public delegate void QueueEmpty(ThrottleOutPacketTypeFlags categories);
+
+    #endregion Delegates
+
+    /// <summary>
+    /// Tracks state for a client UDP connection and provides client-specific methods
+    /// </summary>
+    public sealed class LLUDPClient
+    {
+        // TODO: Make this a config setting
+        /// <summary>Percentage of the task throttle category that is allocated to avatar and prim
+        /// state updates</summary>
+        const float STATE_TASK_PERCENTAGE = 0.8f;
+
+        private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>The number of packet categories to throttle on. If a throttle category is added
+        /// or removed, this number must also change</summary>
+        const int THROTTLE_CATEGORY_COUNT = 8;
+
+        /// <summary>
+        /// Controls whether information is logged about each outbound packet immediately before it is sent.  For debug purposes.
+        /// </summary>
+        /// <remarks>Any level above 0 will turn on logging.</remarks>
+        public int DebugDataOutLevel { get; set; }
+
+        /// <summary>
+        /// Controls whether information is logged about each outbound packet immediately before it is sent.  For debug purposes.
+        /// </summary>
+        /// <remarks>Any level above 0 will turn on logging.</remarks>
+        public int ThrottleDebugLevel
+        {
+            get
+            {
+                return m_throttleDebugLevel;
+            }
+
+            set
+            {
+                m_throttleDebugLevel = value;
+/*
+                m_throttleClient.DebugLevel = m_throttleDebugLevel;
+                foreach (TokenBucket tb in m_throttleCategories)
+                    tb.DebugLevel = m_throttleDebugLevel;
+ */
+            }
+        }
+        private int m_throttleDebugLevel;
+
+        /// <summary>Fired when updated networking stats are produced for this client</summary>
+        public event PacketStats OnPacketStats;
+        /// <summary>Fired when the queue for a packet category is empty. This event can be
+        /// hooked to put more data on the empty queue</summary>
+        public event QueueEmpty OnQueueEmpty;
+
+        public event Func<ThrottleOutPacketTypeFlags, bool> HasUpdates;
+
+        /// <summary>AgentID for this client</summary>
+        public readonly UUID AgentID;
+        /// <summary>The remote address of the connected client</summary>
+        public readonly IPEndPoint RemoteEndPoint;
+        /// <summary>Circuit code that this client is connected on</summary>
+        public readonly uint CircuitCode;
+        /// <summary>Sequence numbers of packets we've received (for duplicate checking)</summary>
+        public IncomingPacketHistoryCollection PacketArchive = new IncomingPacketHistoryCollection(200);
+
+        /// <summary>Packets we have sent that need to be ACKed by the client</summary>
+        public UnackedPacketCollection NeedAcks = new UnackedPacketCollection();
+
+        /// <summary>ACKs that are queued up, waiting to be sent to the client</summary>
+        public DoubleLocklessQueue<uint> PendingAcks = new DoubleLocklessQueue<uint>();
+
+        /// <summary>Current packet sequence number</summary>
+        public int CurrentSequence;
+        /// <summary>Current ping sequence number</summary>
+        public byte CurrentPingSequence;
+        /// <summary>True when this connection is alive, otherwise false</summary>
+        public bool IsConnected = true;
+        /// <summary>True when this connection is paused, otherwise false</summary>
+        public bool IsPaused;
+        /// <summary>Environment.TickCount when the last packet was received for this client</summary>
+        public int TickLastPacketReceived;
+
+        /// <summary>Smoothed round-trip time. A smoothed average of the round-trip time for sending a
+        /// reliable packet to the client and receiving an ACK</summary>
+        public float SRTT;
+        /// <summary>Round-trip time variance. Measures the consistency of round-trip times</summary>
+        public float RTTVAR;
+        /// <summary>Retransmission timeout. Packets that have not been acknowledged in this number of
+        /// milliseconds or longer will be resent</summary>
+        /// <remarks>Calculated from <seealso cref="SRTT"/> and <seealso cref="RTTVAR"/> using the
+        /// guidelines in RFC 2988</remarks>
+        public int RTO;
+        /// <summary>Number of bytes received since the last acknowledgement was sent out. This is used
+        /// to loosely follow the TCP delayed ACK algorithm in RFC 1122 (4.2.3.2)</summary>
+        public int BytesSinceLastACK;
+        /// <summary>Number of packets received from this client</summary>
+        public int PacketsReceived;
+        /// <summary>Number of packets sent to this client</summary>
+        public int PacketsSent;
+        /// <summary>Number of packets resent to this client</summary>
+        public int PacketsResent;
+        /// <summary>Total byte count of unacked packets sent to this client</summary>
+        public int UnackedBytes;
+
+        private int m_packetsUnAckReported;
+        /// <summary>Total number of received packets that we have reported to the OnPacketStats event(s)</summary>
+        private int m_packetsReceivedReported;
+        /// <summary>Total number of sent packets that we have reported to the OnPacketStats event(s)</summary>
+        private int m_packetsSentReported;
+        /// <summary>Holds the Environment.TickCount value of when the next OnQueueEmpty can be fired</summary>
+        private double m_nextOnQueueEmpty = 0;
+
+        /// <summary>Throttle bucket for this agent's connection</summary>
+        private AdaptiveTokenBucket m_throttleClient;
+        public AdaptiveTokenBucket FlowThrottle
+        {
+            get { return m_throttleClient; }
+        }
+
+        /// <summary>Throttle buckets for each packet category</summary>
+        private readonly TokenBucket[] m_throttleCategories;
+        /// <summary>Outgoing queues for throttled packets</summary>
+        private DoubleLocklessQueue<OutgoingPacket>[] m_packetOutboxes = new DoubleLocklessQueue<OutgoingPacket>[THROTTLE_CATEGORY_COUNT];
+        /// <summary>A container that can hold one packet for each outbox, used to store
+        /// dequeued packets that are being held for throttling</summary>
+        private OutgoingPacket[] m_nextPackets = new OutgoingPacket[THROTTLE_CATEGORY_COUNT];
+        /// <summary>A reference to the LLUDPServer that is managing this client</summary>
+        private readonly LLUDPServer m_udpServer;
+
+        /// <summary>Caches packed throttle information</summary>
+        private byte[] m_packedThrottles;
+
+        private int m_defaultRTO = 1000; // 1sec is the recommendation in the RFC
+        private int m_maxRTO = 60000;
+        public bool m_deliverPackets = true;
+
+        private float m_burstTime;
+
+        public int m_lastStartpingTimeMS;
+        public int m_pingMS;
+
+        public int PingTimeMS
+        {
+            get
+            {
+                if (m_pingMS < 10)
+                    return 10;
+                if(m_pingMS > 2000)
+                    return 2000;
+                return m_pingMS;
+            }
+        }
+
+        /// <summary>
+        /// This is the percentage of the udp texture queue to add to the task queue since
+        /// textures are now generally handled through http.
+        /// </summary>
+        private double m_cannibalrate = 0.0;
+
+        private ClientInfo m_info = new ClientInfo();
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="server">Reference to the UDP server this client is connected to</param>
+        /// <param name="rates">Default throttling rates and maximum throttle limits</param>
+        /// <param name="parentThrottle">Parent HTB (hierarchical token bucket)
+        /// that the child throttles will be governed by</param>
+        /// <param name="circuitCode">Circuit code for this connection</param>
+        /// <param name="agentID">AgentID for the connected agent</param>
+        /// <param name="remoteEndPoint">Remote endpoint for this connection</param>
+        /// <param name="defaultRTO">
+        /// Default retransmission timeout for unacked packets.  The RTO will never drop
+        /// beyond this number.
+        /// </param>
+        /// <param name="maxRTO">
+        /// The maximum retransmission timeout for unacked packets.  The RTO will never exceed this number.
+        /// </param>
+        public LLUDPClient(
+            LLUDPServer server, ThrottleRates rates, TokenBucket parentThrottle, uint circuitCode, UUID agentID,
+            IPEndPoint remoteEndPoint, int defaultRTO, int maxRTO)
+        {
+            AgentID = agentID;
+            RemoteEndPoint = remoteEndPoint;
+            CircuitCode = circuitCode;
+            m_udpServer = server;
+            if (defaultRTO != 0)
+                m_defaultRTO = defaultRTO;
+            if (maxRTO != 0)
+                m_maxRTO = maxRTO;
+
+            m_burstTime = rates.BrustTime;
+            float m_burst = rates.ClientMaxRate * m_burstTime;
+
+            // Create a token bucket throttle for this client that has the scene token bucket as a parent
+            m_throttleClient = new AdaptiveTokenBucket(parentThrottle, rates.ClientMaxRate, m_burst, rates.AdaptiveThrottlesEnabled);
+
+            // Create an array of token buckets for this clients different throttle categories
+            m_throttleCategories = new TokenBucket[THROTTLE_CATEGORY_COUNT];
+
+            m_cannibalrate = rates.CannibalizeTextureRate;
+
+            m_burst = rates.Total * rates.BrustTime;
+
+            for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
+            {
+                ThrottleOutPacketType type = (ThrottleOutPacketType)i;
+
+                // Initialize the packet outboxes, where packets sit while they are waiting for tokens
+                m_packetOutboxes[i] = new DoubleLocklessQueue<OutgoingPacket>();
+                // Initialize the token buckets that control the throttling for each category
+                m_throttleCategories[i] = new TokenBucket(m_throttleClient, rates.GetRate(type), m_burst);
+            }
+
+            // Default the retransmission timeout to one second
+            RTO = m_defaultRTO;
+
+            // Initialize this to a sane value to prevent early disconnects
+            TickLastPacketReceived = Environment.TickCount & Int32.MaxValue;
+            m_pingMS = (int)(3.0 * server.TickCountResolution); // so filter doesnt start at 0;
+        }
+
+        /// <summary>
+        /// Shuts down this client connection
+        /// </summary>
+        public void Shutdown()
+        {
+            IsConnected = false;
+            for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
+            {
+                m_packetOutboxes[i].Clear();
+                m_nextPackets[i] = null;
+            }
+
+            // pull the throttle out of the scene throttle
+            m_throttleClient.Parent.UnregisterRequest(m_throttleClient);
+            PendingAcks.Clear();
+            NeedAcks.Clear();
+         }
+
+        /// <summary>
+        /// Gets information about this client connection
+        /// </summary>
+        /// <returns>Information about the client connection</returns>
+        public ClientInfo GetClientInfo()
+        {
+            // TODO: This data structure is wrong in so many ways. Locking and copying the entire lists
+            // of pending and needed ACKs for every client every time some method wants information about
+            // this connection is a recipe for poor performance
+
+            m_info.resendThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Resend].DripRate;
+            m_info.landThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Land].DripRate;
+            m_info.windThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Wind].DripRate;
+            m_info.cloudThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Cloud].DripRate;
+            m_info.taskThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Task].DripRate;
+            m_info.assetThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Asset].DripRate;
+            m_info.textureThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Texture].DripRate;
+            m_info.totalThrottle = (int)m_throttleClient.DripRate;
+            return m_info;
+        }
+
+        /// <summary>
+        /// Modifies the UDP throttles
+        /// </summary>
+        /// <param name="info">New throttling values</param>
+        public void SetClientInfo(ClientInfo info)
+        {
+            // TODO: Allowing throttles to be manually set from this function seems like a reasonable
+            // idea. On the other hand, letting external code manipulate our ACK accounting is not
+            // going to happen
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Get the total number of pakcets queued for this client.
+        /// </summary>
+        /// <returns></returns>
+        public int GetTotalPacketsQueuedCount()
+        {
+            int total = 0;
+
+            for (int i = 0; i <= (int)ThrottleOutPacketType.Asset; i++)
+                total += m_packetOutboxes[i].Count;
+
+            return total;
+        }
+
+        /// <summary>
+        /// Get the number of packets queued for the given throttle type.
+        /// </summary>
+        /// <returns></returns>
+        /// <param name="throttleType"></param>
+        public int GetPacketsQueuedCount(ThrottleOutPacketType throttleType)
+        {
+            int icat = (int)throttleType;
+            if (icat > 0 && icat < THROTTLE_CATEGORY_COUNT)
+                return m_packetOutboxes[icat].Count;
+            else
+                return 0;
+        }
+
+        /// <summary>
+        /// Return statistics information about client packet queues.
+        /// </summary>
+        /// <remarks>
+        /// FIXME: This should really be done in a more sensible manner rather than sending back a formatted string.
+        /// </remarks>
+        /// <returns></returns>
+        public string GetStats()
+        {
+            return string.Format(
+                "{0,7} {1,7} {2,7} {3,9} {4,7} {5,7} {6,7} {7,7} {8,7} {9,8} {10,7} {11,7}",
+                Util.EnvironmentTickCountSubtract(TickLastPacketReceived),
+                PacketsReceived,
+                PacketsSent,
+                PacketsResent,
+                UnackedBytes,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Resend].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Land].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Wind].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Cloud].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Task].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Texture].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Asset].Count);
+        }
+
+        public void SendPacketStats()
+        {
+            PacketStats callback = OnPacketStats;
+            if (callback != null)
+            {
+                int newPacketsReceived = PacketsReceived - m_packetsReceivedReported;
+                int newPacketsSent = PacketsSent - m_packetsSentReported;
+                int newPacketUnAck = UnackedBytes - m_packetsUnAckReported;
+                callback(newPacketsReceived, newPacketsSent, UnackedBytes);
+
+                m_packetsReceivedReported += newPacketsReceived;
+                m_packetsSentReported += newPacketsSent;
+                m_packetsUnAckReported += newPacketUnAck;
+            }
+        }
+
+        public void SetThrottles(byte[] throttleData)
+        {
+            SetThrottles(throttleData, 1.0f);
+        }
+
+        public void SetThrottles(byte[] throttleData, float factor)
+        {
+            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
+            float scale = 0.125f * factor;
+            int resend = (int)(BitConverter.ToSingle(adjData, pos) * scale); pos += 4;
+            int land = (int)(BitConverter.ToSingle(adjData, pos) * scale); pos += 4;
+            int wind = (int)(BitConverter.ToSingle(adjData, pos) * scale); pos += 4;
+            int cloud = (int)(BitConverter.ToSingle(adjData, pos) * scale); pos += 4;
+            int task = (int)(BitConverter.ToSingle(adjData, pos) * scale); pos += 4;
+            int texture = (int)(BitConverter.ToSingle(adjData, pos) * scale); pos += 4;
+            int asset = (int)(BitConverter.ToSingle(adjData, pos) * scale);
+
+
+
+            // Make sure none of the throttles are set below our packet MTU,
+            // otherwise a throttle could become permanently clogged
+
+/* now using floats
+            resend = Math.Max(resend, LLUDPServer.MTU);
+            land = Math.Max(land, LLUDPServer.MTU);
+            wind = Math.Max(wind, LLUDPServer.MTU);
+            cloud = Math.Max(cloud, LLUDPServer.MTU);
+            task = Math.Max(task, LLUDPServer.MTU);
+            texture = Math.Max(texture, LLUDPServer.MTU);
+            asset = Math.Max(asset, LLUDPServer.MTU);
+*/
+
+            // Since most textures are now delivered through http, make it possible
+            // to cannibalize some of the bw from the texture throttle to use for
+            // the task queue (e.g. object updates)
+            task = task + (int)(m_cannibalrate * texture);
+            texture = (int)((1 - m_cannibalrate) * texture);
+
+            int total = resend + land + wind + cloud + task + texture + asset;
+
+            float m_burst = total * m_burstTime;
+
+            if (ThrottleDebugLevel > 0)
+            {
+                m_log.DebugFormat(
+                    "[LLUDPCLIENT]: {0} is setting throttles in {1} to Resend={2}, Land={3}, Wind={4}, Cloud={5}, Task={6}, Texture={7}, Asset={8}, TOTAL = {9}",
+                    AgentID, m_udpServer.Scene.Name, resend, land, wind, cloud, task, texture, asset, total);
+            }
+
+            TokenBucket bucket;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Resend];
+            bucket.RequestedDripRate = resend;
+            bucket.RequestedBurst = m_burst;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Land];
+            bucket.RequestedDripRate = land;
+            bucket.RequestedBurst = m_burst;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Wind];
+            bucket.RequestedDripRate = wind;
+            bucket.RequestedBurst = m_burst;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Cloud];
+            bucket.RequestedDripRate = cloud;
+            bucket.RequestedBurst = m_burst;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Asset];
+            bucket.RequestedDripRate = asset;
+            bucket.RequestedBurst = m_burst;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Task];
+            bucket.RequestedDripRate = task;
+            bucket.RequestedBurst = m_burst;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Texture];
+            bucket.RequestedDripRate = texture;
+            bucket.RequestedBurst = m_burst;
+
+            // Reset the packed throttles cached data
+            m_packedThrottles = null;
+        }
+
+        public byte[] GetThrottlesPacked(float multiplier)
+        {
+            byte[] data = m_packedThrottles;
+
+            if (data == null)
+            {
+                float rate;
+
+                data = new byte[7 * 4];
+                int i = 0;
+
+                // multiply by 8 to convert bytes back to bits
+                multiplier *= 8;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Resend].RequestedDripRate * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Land].RequestedDripRate * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Wind].RequestedDripRate * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Cloud].RequestedDripRate * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Task].RequestedDripRate * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Texture].RequestedDripRate * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Asset].RequestedDripRate * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                m_packedThrottles = data;
+            }
+
+            return data;
+        }
+
+        public int GetCatBytesCanSend(ThrottleOutPacketType cat, int timeMS)
+        {
+            int icat = (int)cat;
+            if (icat > 0 && icat < THROTTLE_CATEGORY_COUNT)
+            {
+                TokenBucket bucket = m_throttleCategories[icat];
+                return bucket.GetCatBytesCanSend(timeMS);
+            }
+            else
+                return 0;
+        }
+
+        /// <summary>
+        /// Queue an outgoing packet if appropriate.
+        /// </summary>
+        /// <param name="packet"></param>
+        /// <param name="forceQueue">Always queue the packet if at all possible.</param>
+        /// <returns>
+        /// true if the packet has been queued,
+        /// false if the packet has not been queued and should be sent immediately.
+        /// </returns>
+        public bool EnqueueOutgoing(OutgoingPacket packet, bool forceQueue)
+        {
+            return EnqueueOutgoing(packet, forceQueue, false);
+        }
+
+        public bool EnqueueOutgoing(OutgoingPacket packet, bool forceQueue, bool highPriority)
+        {
+            int category = (int)packet.Category;
+
+            if (category >= 0 && category < m_packetOutboxes.Length)
+            {
+                DoubleLocklessQueue<OutgoingPacket> queue = m_packetOutboxes[category];
+
+                if (m_deliverPackets == false)
+                {
+                    queue.Enqueue(packet, highPriority);
+                    return true;
+                }
+
+                TokenBucket bucket = m_throttleCategories[category];
+
+                // Don't send this packet if queue is not empty
+                if (queue.Count > 0 || m_nextPackets[category] != null)
+                {
+                    queue.Enqueue(packet, highPriority);
+                    return true;
+                }
+
+                if (!forceQueue && bucket.CheckTokens(packet.Buffer.DataLength))
+                {
+                    // enough tokens so it can be sent imediatly by caller
+                    bucket.RemoveTokens(packet.Buffer.DataLength);
+                    return false;
+                }
+                else
+                {
+                    // Force queue specified or not enough tokens in the bucket, queue this packet
+                    queue.Enqueue(packet, highPriority);
+                    return true;
+                }
+            }
+            else
+            {
+                // We don't have a token bucket for this category, so it will not be queued
+                return false;
+            }
+
+        }
+
+        /// <summary>
+        /// Loops through all of the packet queues for this client and tries to send
+        /// an outgoing packet from each, obeying the throttling bucket limits
+        /// </summary>
+        ///
+        /// <remarks>
+        /// Packet queues are inspected in ascending numerical order starting from 0.  Therefore, queues with a lower
+        /// ThrottleOutPacketType number will see their packet get sent first (e.g. if both Land and Wind queues have
+        /// packets, then the packet at the front of the Land queue will be sent before the packet at the front of the
+        /// wind queue).
+        ///
+        /// This function is only called from a synchronous loop in the
+        /// UDPServer so we don't need to bother making this thread safe
+        /// </remarks>
+        ///
+        /// <returns>True if any packets were sent, otherwise false</returns>
+        public bool DequeueOutgoing()
+        {
+//            if (m_deliverPackets == false) return false;
+
+            OutgoingPacket packet = null;
+            DoubleLocklessQueue<OutgoingPacket> queue;
+            TokenBucket bucket;
+            bool packetSent = false;
+            ThrottleOutPacketTypeFlags emptyCategories = 0;
+
+            //string queueDebugOutput = String.Empty; // Serious debug business
+
+            for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
+            {
+                bucket = m_throttleCategories[i];
+                //queueDebugOutput += m_packetOutboxes[i].Count + " ";  // Serious debug business
+
+                if (m_nextPackets[i] != null)
+                {
+                    // This bucket was empty the last time we tried to send a packet,
+                    // leaving a dequeued packet still waiting to be sent out. Try to
+                    // send it again
+                    OutgoingPacket nextPacket = m_nextPackets[i];
+                    if (bucket.RemoveTokens(nextPacket.Buffer.DataLength))
+                    {
+                        // Send the packet
+                        m_udpServer.SendPacketFinal(nextPacket);
+                        m_nextPackets[i] = null;
+                        packetSent = true;
+
+                        if (m_packetOutboxes[i].Count < 5)
+                            emptyCategories |= CategoryToFlag(i);
+                    }
+                }
+                else
+                {
+                    // No dequeued packet waiting to be sent, try to pull one off
+                    // this queue
+                    queue = m_packetOutboxes[i];
+                    if (queue != null)
+                    {
+                        bool success = false;
+                        try
+                        {
+                            success = queue.Dequeue(out packet);
+                        }
+                        catch
+                        {
+                            m_packetOutboxes[i] = new DoubleLocklessQueue<OutgoingPacket>();
+                        }
+                        if (success)
+                        {
+                            // A packet was pulled off the queue. See if we have
+                            // enough tokens in the bucket to send it out
+                            if (bucket.RemoveTokens(packet.Buffer.DataLength))
+                            {
+                                // Send the packet
+                                m_udpServer.SendPacketFinal(packet);
+                                packetSent = true;
+
+                                if (queue.Count < 5)
+                                    emptyCategories |= CategoryToFlag(i);
+                            }
+                            else
+                            {
+                                // Save the dequeued packet for the next iteration
+                                m_nextPackets[i] = packet;
+                            }
+
+                        }
+                        else
+                        {
+                            // No packets in this queue. Fire the queue empty callback
+                            // if it has not been called recently
+                            emptyCategories |= CategoryToFlag(i);
+                        }
+                    }
+                    else
+                    {
+                        m_packetOutboxes[i] = new DoubleLocklessQueue<OutgoingPacket>();
+                        emptyCategories |= CategoryToFlag(i);
+                    }
+                }
+            }
+
+            if (emptyCategories != 0)
+                BeginFireQueueEmpty(emptyCategories);
+
+            //m_log.Info("[LLUDPCLIENT]: Queues: " + queueDebugOutput); // Serious debug business
+            return packetSent;
+        }
+
+        /// <summary>
+        /// Called when an ACK packet is received and a round-trip time for a
+        /// packet is calculated. This is used to calculate the smoothed
+        /// round-trip time, round trip time variance, and finally the
+        /// retransmission timeout
+        /// </summary>
+        /// <param name="r">Round-trip time of a single packet and its
+        /// acknowledgement</param>
+        public void UpdateRoundTrip(float r)
+        {
+            const float ALPHA = 0.125f;
+            const float BETA = 0.25f;
+            const float K = 4.0f;
+
+            if (RTTVAR == 0.0f)
+            {
+                // First RTT measurement
+                SRTT = r;
+                RTTVAR = r * 0.5f;
+            }
+            else
+            {
+                // Subsequence RTT measurement
+                RTTVAR = (1.0f - BETA) * RTTVAR + BETA * Math.Abs(SRTT - r);
+                SRTT = (1.0f - ALPHA) * SRTT + ALPHA * r;
+            }
+
+            int rto = (int)(SRTT + Math.Max(m_udpServer.TickCountResolution, K * RTTVAR));
+
+            // Clamp the retransmission timeout to manageable values
+            rto = Utils.Clamp(rto, m_defaultRTO, m_maxRTO);
+
+            RTO = rto;
+
+            //if (RTO != rto)
+       //          m_log.Debug("[LLUDPCLIENT]: Setting RTO to " + RTO + "ms from " + rto + "ms with an RTTVAR of " +
+                       //RTTVAR + " based on new RTT of " + r + "ms");
+        }
+
+        /// <summary>
+        /// Exponential backoff of the retransmission timeout, per section 5.5
+        /// of RFC 2988
+        /// </summary>
+        public void BackoffRTO()
+        {
+            // Reset SRTT and RTTVAR, we assume they are bogus since things
+            // didn't work out and we're backing off the timeout
+            SRTT = 0.0f;
+            RTTVAR = 0.0f;
+
+            // Double the retransmission timeout
+            RTO = Math.Min(RTO * 2, m_maxRTO);
+        }
+
+        const double MIN_CALLBACK_MS = 20.0;
+        private bool m_isQueueEmptyRunning;
+
+        /// <summary>
+        /// Does an early check to see if this queue empty callback is already
+        /// running, then asynchronously firing the event
+        /// </summary>
+        /// <param name="categories">Throttle categories to fire the callback for</param>
+        private void BeginFireQueueEmpty(ThrottleOutPacketTypeFlags categories)
+        {
+            if (!m_isQueueEmptyRunning)
+            {
+                if (!HasUpdates(categories))
+                    return;
+
+                double start = Util.GetTimeStampMS();
+                if (start < m_nextOnQueueEmpty)
+                    return;
+
+                m_isQueueEmptyRunning = true;
+                m_nextOnQueueEmpty = start + MIN_CALLBACK_MS;
+
+                // Asynchronously run the callback
+                if (m_udpServer.OqrEngine.IsRunning)
+                    m_udpServer.OqrEngine.QueueJob(AgentID.ToString(), () => FireQueueEmpty(categories));
+                else
+                    Util.FireAndForget(FireQueueEmpty, categories, "LLUDPClient.BeginFireQueueEmpty");
+            }
+        }
+
+
+
+        /// <summary>
+        /// Fires the OnQueueEmpty callback and sets the minimum time that it
+        /// can be called again
+        /// </summary>
+        /// <param name="o">Throttle categories to fire the callback for,
+        /// stored as an object to match the WaitCallback delegate
+        /// signature</param>
+        public void FireQueueEmpty(object o)
+        {
+            ThrottleOutPacketTypeFlags categories = (ThrottleOutPacketTypeFlags)o;
+            QueueEmpty callback = OnQueueEmpty;
+
+            if (callback != null)
+            {
+                // if (m_udpServer.IsRunningOutbound)
+                // {
+                try { callback(categories); }
+                catch (Exception e) { m_log.Error("[LLUDPCLIENT]: OnQueueEmpty(" + categories + ") threw an exception: " + e.Message, e); }
+                // }
+            }
+
+            m_isQueueEmptyRunning = false;
+        }
+
+        internal void ForceThrottleSetting(int throttle, int setting)
+        {
+            if (throttle > 0 && throttle < THROTTLE_CATEGORY_COUNT)
+                m_throttleCategories[throttle].RequestedDripRate = Math.Max(setting, LLUDPServer.MTU);
+        }
+
+        internal int GetThrottleSetting(int throttle)
+        {
+            if (throttle > 0 && throttle < THROTTLE_CATEGORY_COUNT)
+                return (int)m_throttleCategories[throttle].RequestedDripRate;
+            else
+                return 0;
+        }
+
+        /// <summary>
+        /// Converts a <seealso cref="ThrottleOutPacketType"/> integer to a
+        /// flag value
+        /// </summary>
+        /// <param name="i">Throttle category to convert</param>
+        /// <returns>Flag representation of the throttle category</returns>
+        private static ThrottleOutPacketTypeFlags CategoryToFlag(int i)
+        {
+            ThrottleOutPacketType category = (ThrottleOutPacketType)i;
+
+            /*
+             * Land = 1,
+        /// <summary>Wind data</summary>
+        Wind = 2,
+        /// <summary>Cloud data</summary>
+        Cloud = 3,
+        /// <summary>Any packets that do not fit into the other throttles</summary>
+        Task = 4,
+        /// <summary>Texture assets</summary>
+        Texture = 5,
+        /// <summary>Non-texture assets</summary>
+        Asset = 6,
+             */
+
+            switch (category)
+            {
+                case ThrottleOutPacketType.Land:
+                    return ThrottleOutPacketTypeFlags.Land;
+                case ThrottleOutPacketType.Wind:
+                    return ThrottleOutPacketTypeFlags.Wind;
+                case ThrottleOutPacketType.Cloud:
+                    return ThrottleOutPacketTypeFlags.Cloud;
+                case ThrottleOutPacketType.Task:
+                    return ThrottleOutPacketTypeFlags.Task;
+                case ThrottleOutPacketType.Texture:
+                    return ThrottleOutPacketTypeFlags.Texture;
+                case ThrottleOutPacketType.Asset:
+                    return ThrottleOutPacketTypeFlags.Asset;
+                default:
+                    return 0;
+            }
+        }
+    }
+
+    public class DoubleLocklessQueue<T> : OpenSim.Framework.LocklessQueue<T>
+    {
+        OpenSim.Framework.LocklessQueue<T> highQueue = new OpenSim.Framework.LocklessQueue<T>();
+
+        public override int Count
+        {
+            get
+            {
+                return base.Count + highQueue.Count;
+            }
+        }
+
+        public override bool Dequeue(out T item)
+        {
+            if (highQueue.Dequeue(out item))
+                return true;
+
+            return base.Dequeue(out item);
+        }
+
+        public void Enqueue(T item, bool highPriority)
+        {
+            if (highPriority)
+                highQueue.Enqueue(item);
+            else
+                Enqueue(item);
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
new file mode 100644
index 0000000..69239b1
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
@@ -0,0 +1,2246 @@
+/*
+ * 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.Diagnostics;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using log4net;
+using Nini.Config;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Monitoring;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+using OpenMetaverse;
+using Mono.Addins;
+using TokenBucket = OpenSim.Region.ClientStack.LindenUDP.TokenBucket;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    /// <summary>
+    /// A shim around LLUDPServer that implements the IClientNetworkServer interface
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "LLUDPServerShim")]
+    public class LLUDPServerShim : INonSharedRegionModule
+    {
+        protected IConfigSource m_Config;
+        protected LLUDPServer m_udpServer;
+
+        #region INonSharedRegionModule
+        public virtual string Name
+        {
+            get { return "LLUDPServerShim"; }
+        }
+
+        public virtual Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            m_Config = source;
+        }
+
+        public virtual void Close()
+        {
+        }
+
+        public virtual void AddRegion(Scene scene)
+        {
+            uint port = (uint)scene.RegionInfo.InternalEndPoint.Port;
+
+            IPAddress listenIP = scene.RegionInfo.InternalEndPoint.Address;
+            Initialise(listenIP, ref port, scene.RegionInfo.ProxyOffset, m_Config, scene.AuthenticateHandler);
+            scene.RegionInfo.InternalEndPoint.Port = (int)port;
+
+            AddScene(scene);
+        }
+
+        public virtual void RemoveRegion(Scene scene)
+        {
+            Stop();
+        }
+
+        public virtual void RegionLoaded(Scene scene)
+        {
+            Start();
+        }
+        #endregion
+
+        public virtual void Initialise(IPAddress listenIP, ref uint port, int proxyPortOffsetParm, IConfigSource configSource, AgentCircuitManager circuitManager)
+        {
+            m_udpServer = new LLUDPServer(listenIP, ref port, proxyPortOffsetParm, configSource, circuitManager);
+        }
+
+        public virtual void AddScene(IScene scene)
+        {
+            m_udpServer.AddScene(scene);
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "ClientLogoutsDueToNoReceives",
+                    "Number of times a client has been logged out because no packets were received before the timeout.",
+                    "",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.None,
+                    stat => stat.Value = m_udpServer.ClientLogoutsDueToNoReceives,
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "IncomingUDPReceivesCount",
+                    "Number of UDP receives performed",
+                    "",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = m_udpServer.UdpReceives,
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "IncomingPacketsProcessedCount",
+                    "Number of inbound LL protocol packets processed",
+                    "",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = m_udpServer.IncomingPacketsProcessed,
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "IncomingPacketsMalformedCount",
+                    "Number of inbound UDP packets that could not be recognized as LL protocol packets.",
+                    "",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = m_udpServer.IncomingMalformedPacketCount,
+                    StatVerbosity.Info));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "IncomingPacketsOrphanedCount",
+                    "Number of inbound packets that were not initial connections packets and could not be associated with a viewer.",
+                    "",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = m_udpServer.IncomingOrphanedPacketCount,
+                    StatVerbosity.Info));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "IncomingPacketsResentCount",
+                    "Number of inbound packets that clients indicate are resends.",
+                    "",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = m_udpServer.IncomingPacketsResentCount,
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "OutgoingUDPSendsCount",
+                    "Number of UDP sends performed",
+                    "",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = m_udpServer.UdpSends,
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "OutgoingPacketsResentCount",
+                    "Number of packets resent because a client did not acknowledge receipt",
+                    "",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = m_udpServer.PacketsResentCount,
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "AverageUDPProcessTime",
+                    "Average number of milliseconds taken to process each incoming UDP packet in a sample.",
+                    "This is for initial receive processing which is separate from the later client LL packet processing stage.",
+                    "ms",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.None,
+                    stat => stat.Value = m_udpServer.AverageReceiveTicksForLastSamplePeriod,
+//                    stat =>
+//                        stat.Value = Math.Round(m_udpServer.AverageReceiveTicksForLastSamplePeriod, 7),
+                    StatVerbosity.Debug));
+        }
+
+        public virtual bool HandlesRegion(Location x)
+        {
+            return m_udpServer.HandlesRegion(x);
+        }
+
+        public virtual void Start()
+        {
+            m_udpServer.Start();
+        }
+
+        public virtual void Stop()
+        {
+            m_udpServer.Stop();
+        }
+
+    }
+
+    /// <summary>
+    /// The LLUDP server for a region. This handles incoming and outgoing
+    /// packets for all UDP connections to the region
+    /// </summary>
+    public class LLUDPServer : OpenSimUDPBase
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>Maximum transmission unit, or UDP packet size, for the LLUDP protocol</summary>
+        public const int MTU = 1400;
+
+        /// <summary>Number of forced client logouts due to no receipt of packets before timeout.</summary>
+        public int ClientLogoutsDueToNoReceives { get; protected set; }
+
+        /// <summary>
+        /// Default packet debug level given to new clients
+        /// </summary>
+        public int DefaultClientPacketDebugLevel { get; set; }
+
+        /// <summary>
+        /// If set then all inbound agent updates are discarded.  For debugging purposes.
+        /// discard agent update.
+        /// </summary>
+        public bool DiscardInboundAgentUpdates { get; set; }
+
+        /// <summary>The measured resolution of Environment.TickCount</summary>
+        public readonly float TickCountResolution;
+
+        /// <summary>Number of prim updates to put on the queue each time the
+        /// OnQueueEmpty event is triggered for updates</summary>
+        public readonly int PrimUpdatesPerCallback;
+
+        /// <summary>Number of texture packets to put on the queue each time the
+        /// OnQueueEmpty event is triggered for textures</summary>
+        public readonly int TextureSendLimit;
+
+        /// <summary>Handlers for incoming packets</summary>
+        //PacketEventDictionary packetEvents = new PacketEventDictionary();
+        /// <summary>Incoming packets that are awaiting handling</summary>
+        //protected OpenMetaverse.BlockingQueue<IncomingPacket> packetInbox = new OpenMetaverse.BlockingQueue<IncomingPacket>();
+
+        protected OpenSim.Framework.BlockingQueue<IncomingPacket> packetInbox = new OpenSim.Framework.BlockingQueue<IncomingPacket>();
+
+        /// <summary>Bandwidth throttle for this UDP server</summary>
+        public TokenBucket Throttle { get; protected set; }
+
+        /// <summary>Per client throttle rates enforced by this server</summary>
+        /// <remarks>
+        /// If the total rate is non-zero, then this is the maximum total throttle setting that any client can ever have.
+        /// The other rates (resend, asset, etc.) are the defaults for a new client and can be changed (and usually
+        /// do get changed immediately).  They do not need to sum to the total.
+        /// </remarks>
+        public ThrottleRates ThrottleRates { get; protected set; }
+
+        /// <summary>Manages authentication for agent circuits</summary>
+        protected AgentCircuitManager m_circuitManager;
+
+        /// <summary>Reference to the scene this UDP server is attached to</summary>
+        public Scene Scene { get; protected set; }
+
+        /// <summary>The X/Y coordinates of the scene this UDP server is attached to</summary>
+        protected Location m_location;
+
+        /// <summary>The size of the receive buffer for the UDP socket. This value
+        /// is passed up to the operating system and used in the system networking
+        /// stack. Use zero to leave this value as the default</summary>
+        protected int m_recvBufferSize;
+
+        /// <summary>Tracks whether or not a packet was sent each round so we know
+        /// whether or not to sleep</summary>
+        protected bool m_packetSent;
+
+        /// <summary>Environment.TickCount of the last time that packet stats were reported to the scene</summary>
+        protected int m_elapsedMSSinceLastStatReport = 0;
+
+        /// <summary>Environment.TickCount of the last time the outgoing packet handler executed</summary>
+        protected double m_tickLastOutgoingPacketHandler;
+
+        /// <summary>Keeps track of the number of elapsed milliseconds since the last time the outgoing packet handler looped</summary>
+        protected double m_elapsedMSOutgoingPacketHandler;
+
+        /// <summary>Keeps track of the number of 100 millisecond periods elapsed in the outgoing packet handler executed</summary>
+        protected int m_elapsed100MSOutgoingPacketHandler;
+
+        /// <summary>Keeps track of the number of 500 millisecond periods elapsed in the outgoing packet handler executed</summary>
+        protected int m_elapsed500MSOutgoingPacketHandler;
+
+        /// <summary>Flag to signal when clients should check for resends</summary>
+        protected bool m_resendUnacked;
+
+        /// <summary>Flag to signal when clients should send ACKs</summary>
+        protected bool m_sendAcks;
+
+        /// <summary>Flag to signal when clients should send pings</summary>
+        protected bool m_sendPing;
+
+        protected int m_animationSequenceNumber;
+
+        public int NextAnimationSequenceNumber
+        {
+            get
+            {
+                m_animationSequenceNumber++;
+                if (m_animationSequenceNumber > 2147482624)
+                    m_animationSequenceNumber = 1;
+                return m_animationSequenceNumber;
+            }
+        }
+
+        protected ExpiringCache<IPEndPoint, Queue<UDPPacketBuffer>> m_pendingCache = new ExpiringCache<IPEndPoint, Queue<UDPPacketBuffer>>();
+
+        protected Pool<IncomingPacket> m_incomingPacketPool;
+
+        /// <summary>
+        /// Stat for number of packets in the main pool awaiting use.
+        /// </summary>
+        protected Stat m_poolCountStat;
+
+        /// <summary>
+        /// Stat for number of packets in the inbound packet pool awaiting use.
+        /// </summary>
+        protected Stat m_incomingPacketPoolStat;
+
+        protected int m_defaultRTO = 0;
+        protected int m_maxRTO = 0;
+        protected int m_ackTimeout = 0;
+        protected int m_pausedAckTimeout = 0;
+        protected bool m_disableFacelights = false;
+
+        public Socket Server { get { return null; } }
+
+        /// <summary>
+        /// Record how many packets have been resent
+        /// </summary>
+        internal int PacketsResentCount { get; set; }
+
+        /// <summary>
+        /// Record how many packets have been sent
+        /// </summary>
+        internal int PacketsSentCount { get; set; }
+
+        /// <summary>
+        /// Record how many incoming packets are indicated as resends by clients.
+        /// </summary>
+        internal int IncomingPacketsResentCount { get; set; }
+
+        /// <summary>
+        /// Record how many inbound packets could not be recognized as LLUDP packets.
+        /// </summary>
+        public int IncomingMalformedPacketCount { get; protected set; }
+
+        /// <summary>
+        /// Record how many inbound packets could not be associated with a simulator circuit.
+        /// </summary>
+        public int IncomingOrphanedPacketCount { get; protected set; }
+
+        /// <summary>
+        /// Record current outgoing client for monitoring purposes.
+        /// </summary>
+        protected IClientAPI m_currentOutgoingClient;
+
+        /// <summary>
+        /// Recording current incoming client for monitoring purposes.
+        /// </summary>
+        protected IClientAPI m_currentIncomingClient;
+
+        /// <summary>
+        /// Queue some low priority but potentially high volume async requests so that they don't overwhelm available
+        /// threadpool threads.
+        /// </summary>
+//        public JobEngine IpahEngine { get; protected set; }
+
+        /// <summary>
+        /// Run queue empty processing within a single persistent thread.
+        /// </summary>
+        /// <remarks>
+        /// This is the alternative to having every
+        /// connection schedule its own job in the threadpool which causes performance problems when there are many
+        /// connections.
+        /// </remarks>
+        public JobEngine OqrEngine { get; protected set; }
+
+        public LLUDPServer(
+            IPAddress listenIP, ref uint port, int proxyPortOffsetParm,
+            IConfigSource configSource, AgentCircuitManager circuitManager)
+            : base(listenIP, (int)port)
+        {
+            #region Environment.TickCount Measurement
+
+            // Update the port with the one we actually got
+            port = (uint)Port;
+
+            // Measure the resolution of Environment.TickCount
+            TickCountResolution = 0f;
+            for (int i = 0; i < 10; i++)
+            {
+                int start = Environment.TickCount;
+                int now = start;
+                while (now == start)
+                    now = Environment.TickCount;
+                TickCountResolution += (float)(now - start);
+            }
+            m_log.Info("[LLUDPSERVER]: Average Environment.TickCount resolution: " + TickCountResolution * 0.1f + "ms");
+
+            TickCountResolution = 0f;
+            for (int i = 0; i < 100; i++)
+            {
+                double start = Util.GetTimeStampMS();
+                double now = start;
+                while (now == start)
+                    now = Util.GetTimeStampMS();
+                TickCountResolution += (float)((now - start));
+            }
+
+            TickCountResolution = (float)Math.Round(TickCountResolution * 0.01f,6,MidpointRounding.AwayFromZero);
+            m_log.Info("[LLUDPSERVER]: Average Util.GetTimeStampMS resolution: " + TickCountResolution + "ms");
+
+            #endregion Environment.TickCount Measurement
+
+            m_circuitManager = circuitManager;
+            int sceneThrottleBps = 0;
+            bool usePools = false;
+
+            IConfig config = configSource.Configs["ClientStack.LindenUDP"];
+            if (config != null)
+            {
+                m_recvBufferSize = config.GetInt("client_socket_rcvbuf_size", 0);
+                sceneThrottleBps = config.GetInt("scene_throttle_max_bps", 0);
+
+                PrimUpdatesPerCallback = config.GetInt("PrimUpdatesPerCallback", 100);
+                TextureSendLimit = config.GetInt("TextureSendLimit", 20);
+
+                m_defaultRTO = config.GetInt("DefaultRTO", 0);
+                m_maxRTO = config.GetInt("MaxRTO", 0);
+                m_disableFacelights = config.GetBoolean("DisableFacelights", false);
+                m_ackTimeout = 1000 * config.GetInt("AckTimeout", 60);
+                m_pausedAckTimeout = 1000 * config.GetInt("PausedAckTimeout", 300);
+            }
+            else
+            {
+                PrimUpdatesPerCallback = 100;
+                TextureSendLimit = 20;
+                m_ackTimeout = 1000 * 60; // 1 minute
+                m_pausedAckTimeout = 1000 * 300; // 5 minutes
+            }
+
+            // FIXME: This actually only needs to be done once since the PacketPool is shared across all servers.
+            // However, there is no harm in temporarily doing it multiple times.
+            IConfig packetConfig = configSource.Configs["PacketPool"];
+            if (packetConfig != null)
+            {
+                PacketPool.Instance.RecyclePackets = packetConfig.GetBoolean("RecyclePackets", true);
+                PacketPool.Instance.RecycleDataBlocks = packetConfig.GetBoolean("RecycleDataBlocks", true);
+                usePools = packetConfig.GetBoolean("RecycleBaseUDPPackets", usePools);
+            }
+
+            #region BinaryStats
+            config = configSource.Configs["Statistics.Binary"];
+            m_shouldCollectStats = false;
+            if (config != null)
+            {
+                m_shouldCollectStats = config.GetBoolean("Enabled", false);
+                binStatsMaxFilesize = TimeSpan.FromSeconds(config.GetInt("packet_headers_period_seconds", 300));
+                binStatsDir = config.GetString("stats_dir", ".");
+                m_aggregatedBWStats = config.GetBoolean("aggregatedBWStats", false);
+            }
+            #endregion BinaryStats
+
+            Throttle = new TokenBucket(null, sceneThrottleBps, sceneThrottleBps * 10e-3f);
+            ThrottleRates = new ThrottleRates(configSource);
+
+            Random rnd = new Random(Util.EnvironmentTickCount());
+            m_animationSequenceNumber = rnd.Next(11474826);
+
+//            if (usePools)
+//                EnablePools();
+            base.DisablePools();
+        }
+
+        public void Start()
+        {
+            StartInbound();
+            StartOutbound();
+//            IpahEngine.Start();
+            OqrEngine.Start();
+
+            m_elapsedMSSinceLastStatReport = Environment.TickCount;
+        }
+
+        public void StartInbound()
+        {
+            m_log.InfoFormat(
+                "[LLUDPSERVER]: Starting inbound packet processing for the LLUDP server");
+
+            base.StartInbound(m_recvBufferSize);
+
+            // This thread will process the packets received that are placed on the packetInbox
+            WorkManager.StartThread(
+                IncomingPacketHandler,
+                string.Format("Incoming Packets ({0})", Scene.Name),
+                ThreadPriority.Normal,
+                false,
+                true,
+                GetWatchdogIncomingAlarmData,
+                Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS);
+        }
+
+        public override void StartOutbound()
+        {
+            m_log.Info("[LLUDPSERVER]: Starting outbound packet processing for the LLUDP server");
+
+            base.StartOutbound();
+
+            WorkManager.StartThread(
+                OutgoingPacketHandler,
+                string.Format("Outgoing Packets ({0})", Scene.Name),
+                ThreadPriority.Normal,
+                false,
+                true,
+                GetWatchdogOutgoingAlarmData,
+                Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS);
+        }
+
+        public void Stop()
+        {
+            m_log.Info("[LLUDPSERVER]: Shutting down the LLUDP server for " + Scene.Name);
+            base.StopOutbound();
+            base.StopInbound();
+//            IpahEngine.Stop();
+            OqrEngine.Stop();
+        }
+
+        public override bool EnablePools()
+        {
+            if (!UsePools)
+            {
+                base.EnablePools();
+
+                m_incomingPacketPool = new Pool<IncomingPacket>(() => new IncomingPacket(), 500);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public override bool DisablePools()
+        {
+            if (UsePools)
+            {
+                base.DisablePools();
+
+                StatsManager.DeregisterStat(m_incomingPacketPoolStat);
+
+                // We won't null out the pool to avoid a race condition with code that may be in the middle of using it.
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// This is a seperate method so that it can be called once we have an m_scene to distinguish different scene
+        /// stats.
+        /// </summary>
+        protected internal void EnablePoolStats()
+        {
+            m_poolCountStat
+                = new Stat(
+                    "UDPPacketBufferPoolCount",
+                    "Objects within the UDPPacketBuffer pool",
+                    "The number of objects currently stored within the UDPPacketBuffer pool",
+                    "",
+                    "clientstack",
+                    Scene.Name,
+                    StatType.Pull,
+                    stat => stat.Value = Pool.Count,
+                    StatVerbosity.Debug);
+
+            StatsManager.RegisterStat(m_poolCountStat);
+
+            m_incomingPacketPoolStat
+                = new Stat(
+                    "IncomingPacketPoolCount",
+                    "Objects within incoming packet pool",
+                    "The number of objects currently stored within the incoming packet pool",
+                    "",
+                    "clientstack",
+                    Scene.Name,
+                    StatType.Pull,
+                    stat => stat.Value = m_incomingPacketPool.Count,
+                    StatVerbosity.Debug);
+
+            StatsManager.RegisterStat(m_incomingPacketPoolStat);
+        }
+
+        /// <summary>
+        /// Disables pool stats.
+        /// </summary>
+        protected internal void DisablePoolStats()
+        {
+            StatsManager.DeregisterStat(m_poolCountStat);
+            m_poolCountStat = null;
+
+            StatsManager.DeregisterStat(m_incomingPacketPoolStat);
+            m_incomingPacketPoolStat = null;
+        }
+
+        /// <summary>
+        /// If the outgoing UDP thread times out, then return client that was being processed to help with debugging.
+        /// </summary>
+        /// <returns></returns>
+        protected string GetWatchdogIncomingAlarmData()
+        {
+            return string.Format(
+                "Client is {0}",
+                m_currentIncomingClient != null ? m_currentIncomingClient.Name : "none");
+        }
+
+        /// <summary>
+        /// If the outgoing UDP thread times out, then return client that was being processed to help with debugging.
+        /// </summary>
+        /// <returns></returns>
+        protected string GetWatchdogOutgoingAlarmData()
+        {
+            return string.Format(
+                "Client is {0}",
+                m_currentOutgoingClient != null ? m_currentOutgoingClient.Name : "none");
+        }
+
+        public void AddScene(IScene scene)
+        {
+            if (Scene != null)
+            {
+                m_log.Error("[LLUDPSERVER]: AddScene() called on an LLUDPServer that already has a scene");
+                return;
+            }
+
+            if (!(scene is Scene))
+            {
+                m_log.Error("[LLUDPSERVER]: AddScene() called with an unrecognized scene type " + scene.GetType());
+                return;
+            }
+
+            Scene = (Scene)scene;
+            m_location = new Location(Scene.RegionInfo.RegionHandle);
+/*
+            IpahEngine
+                = new JobEngine(
+                    string.Format("Incoming Packet Async Handling Engine ({0})", Scene.Name),
+                    "INCOMING PACKET ASYNC HANDLING ENGINE");
+*/
+            OqrEngine
+                = new JobEngine(
+                    string.Format("Outgoing Queue Refill Engine ({0})", Scene.Name),
+                    "OUTGOING QUEUE REFILL ENGINE");
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "InboxPacketsCount",
+                    "Number of LL protocol packets waiting for the second stage of processing after initial receive.",
+                    "Number of LL protocol packets waiting for the second stage of processing after initial receive.",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = packetInbox.Count(),
+                    StatVerbosity.Debug));
+
+            // XXX: These stats are also pool stats but we register them separately since they are currently not
+            // turned on and off by EnablePools()/DisablePools()
+            StatsManager.RegisterStat(
+                new PercentageStat(
+                    "PacketsReused",
+                    "Packets reused",
+                    "Number of packets reused out of all requests to the packet pool",
+                    "clientstack",
+                    Scene.Name,
+                    StatType.Pull,
+                    stat =>
+                        { PercentageStat pstat = (PercentageStat)stat;
+                          pstat.Consequent = PacketPool.Instance.PacketsRequested;
+                          pstat.Antecedent = PacketPool.Instance.PacketsReused; },
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new PercentageStat(
+                    "PacketDataBlocksReused",
+                    "Packet data blocks reused",
+                    "Number of data blocks reused out of all requests to the packet pool",
+                    "clientstack",
+                    Scene.Name,
+                    StatType.Pull,
+                    stat =>
+                        { PercentageStat pstat = (PercentageStat)stat;
+                          pstat.Consequent = PacketPool.Instance.BlocksRequested;
+                          pstat.Antecedent = PacketPool.Instance.BlocksReused; },
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "PacketsPoolCount",
+                    "Objects within the packet pool",
+                    "The number of objects currently stored within the packet pool",
+                    "",
+                    "clientstack",
+                    Scene.Name,
+                    StatType.Pull,
+                    stat => stat.Value = PacketPool.Instance.PacketsPooled,
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "PacketDataBlocksPoolCount",
+                    "Objects within the packet data block pool",
+                    "The number of objects currently stored within the packet data block pool",
+                    "",
+                    "clientstack",
+                    Scene.Name,
+                    StatType.Pull,
+                    stat => stat.Value = PacketPool.Instance.BlocksPooled,
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "OutgoingPacketsQueuedCount",
+                    "Packets queued for outgoing send",
+                    "Number of queued outgoing packets across all connections",
+                    "",
+                    "clientstack",
+                    Scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = GetTotalQueuedOutgoingPackets(),
+                    StatVerbosity.Info));
+/*
+            StatsManager.RegisterStat(
+                new Stat(
+                    "IncomingPacketAsyncRequestsWaiting",
+                    "Number of incoming packets waiting for async processing in engine.",
+                    "",
+                    "",
+                    "clientstack",
+                    Scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.None,
+                    stat => stat.Value = IpahEngine.JobsWaiting,
+                    StatVerbosity.Debug));
+*/
+            StatsManager.RegisterStat(
+                new Stat(
+                    "OQRERequestsWaiting",
+                    "Number of outgong queue refill requests waiting for processing.",
+                    "",
+                    "",
+                    "clientstack",
+                    Scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.None,
+                    stat => stat.Value = OqrEngine.JobsWaiting,
+                    StatVerbosity.Debug));
+
+            // We delay enabling pool stats to AddScene() instead of Initialize() so that we can distinguish pool stats by
+            // scene name
+            if (UsePools)
+                EnablePoolStats();
+
+
+            LLUDPServerCommands commands = new LLUDPServerCommands(MainConsole.Instance, this);
+            commands.Register();
+
+        }
+
+        public bool HandlesRegion(Location x)
+        {
+            return x == m_location;
+        }
+
+        public int GetTotalQueuedOutgoingPackets()
+        {
+            int total = 0;
+
+            foreach (ScenePresence sp in Scene.GetScenePresences())
+            {
+                // XXX: Need a better way to determine which IClientAPIs have UDPClients (NPCs do not, for instance).
+                if (sp.ControllingClient is LLClientView)
+                {
+                    LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+                    total += udpClient.GetTotalPacketsQueuedCount();
+                }
+            }
+
+            return total;
+        }
+
+//        public void BroadcastPacket(Packet packet, ThrottleOutPacketType category, bool sendToPausedAgents, bool allowSplitting)
+//        {
+//            // CoarseLocationUpdate and AvatarGroupsReply packets cannot be split in an automated way
+//            if ((packet.Type == PacketType.CoarseLocationUpdate || packet.Type == PacketType.AvatarGroupsReply) && allowSplitting)
+//                allowSplitting = false;
+//
+//            if (allowSplitting && packet.HasVariableBlocks)
+//            {
+//                byte[][] datas = packet.ToBytesMultiple();
+//                int packetCount = datas.Length;
+//
+//                if (packetCount < 1)
+//                    m_log.Error("[LLUDPSERVER]: Failed to split " + packet.Type + " with estimated length " + packet.Length);
+//
+//                for (int i = 0; i < packetCount; i++)
+//                {
+//                    byte[] data = datas[i];
+//                    m_scene.ForEachClient(
+//                        delegate(IClientAPI client)
+//                        {
+//                            if (client is LLClientView)
+//                                SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category, null);
+//                        }
+//                    );
+//                }
+//            }
+//            else
+//            {
+//                byte[] data = packet.ToBytes();
+//                m_scene.ForEachClient(
+//                    delegate(IClientAPI client)
+//                    {
+//                        if (client is LLClientView)
+//                            SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category, null);
+//                    }
+//                );
+//            }
+//        }
+
+        /// <summary>
+        /// Start the process of sending a packet to the client.
+        /// </summary>
+        /// <param name="udpClient"></param>
+        /// <param name="packet"></param>
+        /// <param name="category"></param>
+        /// <param name="allowSplitting"></param>
+        /// <param name="method">
+        /// The method to call if the packet is not acked by the client.  If null, then a standard
+        /// resend of the packet is done.
+        /// </param>
+        public virtual void SendPacket(
+            LLUDPClient udpClient, Packet packet, ThrottleOutPacketType category, bool allowSplitting, UnackedPacketMethod method)
+        {
+            // CoarseLocationUpdate packets cannot be split in an automated way
+            if (packet.Type == PacketType.CoarseLocationUpdate && allowSplitting)
+                allowSplitting = false;
+
+            bool packetQueued = false;
+
+            if (allowSplitting && packet.HasVariableBlocks)
+            {
+                byte[][] datas = packet.ToBytesMultiple();
+                int packetCount = datas.Length;
+
+                if (packetCount < 1)
+                    m_log.Error("[LLUDPSERVER]: Failed to split " + packet.Type + " with estimated length " + packet.Length);
+
+                for (int i = 0; i < packetCount; i++)
+                {
+                    byte[] data = datas[i];
+                    if (!SendPacketData(udpClient, data, packet.Type, category, method))
+                        packetQueued = true;
+                }
+            }
+            else
+            {
+                byte[] data = packet.ToBytes();
+                if (!SendPacketData(udpClient, data, packet.Type, category, method))
+                    packetQueued = true;
+            }
+
+            PacketPool.Instance.ReturnPacket(packet);
+        }
+
+        /// <summary>
+        /// Start the process of sending a packet to the client.
+        /// </summary>
+        /// <param name="udpClient"></param>
+        /// <param name="data"></param>
+        /// <param name="type"></param>
+        /// <param name="category"></param>
+        /// <param name="method">
+        /// The method to call if the packet is not acked by the client.  If null, then a standard
+        /// resend of the packet is done.
+        /// </param>
+        /// <returns>true if the data was sent immediately, false if it was queued for sending</returns>
+        public bool SendPacketData(
+            LLUDPClient udpClient, byte[] data, PacketType type, ThrottleOutPacketType category, UnackedPacketMethod method)
+        {
+            int dataLength = data.Length;
+            bool doZerocode = (data[0] & Helpers.MSG_ZEROCODED) != 0;
+            bool doCopy = true;
+
+            // Frequency analysis of outgoing packet sizes shows a large clump of packets at each end of the spectrum.
+            // The vast majority of packets are less than 200 bytes, although due to asset transfers and packet splitting
+            // there are a decent number of packets in the 1000-1140 byte range. We allocate one of two sizes of data here
+            // to accomodate for both common scenarios and provide ample room for ACK appending in both
+            int bufferSize = (dataLength > 180) ? LLUDPServer.MTU : 200;
+
+            UDPPacketBuffer buffer = new UDPPacketBuffer(udpClient.RemoteEndPoint, bufferSize);
+
+            // Zerocode if needed
+            if (doZerocode)
+            {
+                try
+                {
+                    dataLength = Helpers.ZeroEncode(data, dataLength, buffer.Data);
+                    doCopy = false;
+                }
+                catch (IndexOutOfRangeException)
+                {
+                    // The packet grew larger than the bufferSize while zerocoding.
+                    // Remove the MSG_ZEROCODED flag and send the unencoded data
+                    // instead
+                    m_log.Debug("[LLUDPSERVER]: Packet exceeded buffer size during zerocoding for " + type + ". DataLength=" + dataLength +
+                        " and BufferLength=" + buffer.Data.Length + ". Removing MSG_ZEROCODED flag");
+                    data[0] = (byte)(data[0] & ~Helpers.MSG_ZEROCODED);
+                }
+            }
+
+            // If the packet data wasn't already copied during zerocoding, copy it now
+            if (doCopy)
+            {
+                if (dataLength <= buffer.Data.Length)
+                {
+                    Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
+                }
+                else
+                {
+                    bufferSize = dataLength;
+                    buffer = new UDPPacketBuffer(udpClient.RemoteEndPoint, bufferSize);
+
+                    m_log.Error("[LLUDPSERVER]: Packet exceeded buffer size! This could be an indication of packet assembly not obeying the MTU. Type=" +
+                        type + ", DataLength=" + dataLength + ", BufferLength=" + buffer.Data.Length);
+                    Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
+                }
+            }
+
+            buffer.DataLength = dataLength;
+
+            #region Queue or Send
+
+            bool highPriority = false;
+
+            if (category != ThrottleOutPacketType.Unknown && (category & ThrottleOutPacketType.HighPriority) != 0)
+            {
+                category = (ThrottleOutPacketType)((int)category & 127);
+                highPriority = true;
+            }
+
+            OutgoingPacket outgoingPacket = new OutgoingPacket(udpClient, buffer, category, null);
+
+            // If we were not provided a method for handling unacked, use the UDPServer default method
+            if ((outgoingPacket.Buffer.Data[0] & Helpers.MSG_RELIABLE) != 0)
+                outgoingPacket.UnackedMethod = ((method == null) ? delegate(OutgoingPacket oPacket) { ResendUnacked(oPacket); } : method);
+
+            // If a Linden Lab 1.23.5 client receives an update packet after a kill packet for an object, it will
+            // continue to display the deleted object until relog.  Therefore, we need to always queue a kill object
+            // packet so that it isn't sent before a queued update packet.
+
+            bool requestQueue = type == PacketType.KillObject;
+            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket, requestQueue, highPriority))
+            {
+                SendPacketFinal(outgoingPacket);
+                return true;
+            }
+
+            return false;
+
+            #endregion Queue or Send
+        }
+
+        public void SendAcks(LLUDPClient udpClient)
+        {
+            uint ack;
+
+            if (udpClient.PendingAcks.Dequeue(out ack))
+            {
+                List<PacketAckPacket.PacketsBlock> blocks = new List<PacketAckPacket.PacketsBlock>();
+                PacketAckPacket.PacketsBlock block = new PacketAckPacket.PacketsBlock();
+                block.ID = ack;
+                blocks.Add(block);
+
+                while (udpClient.PendingAcks.Dequeue(out ack))
+                {
+                    block = new PacketAckPacket.PacketsBlock();
+                    block.ID = ack;
+                    blocks.Add(block);
+                }
+
+                PacketAckPacket packet = new PacketAckPacket();
+                packet.Header.Reliable = false;
+                packet.Packets = blocks.ToArray();
+
+                SendPacket(udpClient, packet, ThrottleOutPacketType.Unknown, true, null);
+            }
+        }
+
+        public void SendPing(LLUDPClient udpClient)
+        {
+            StartPingCheckPacket pc = (StartPingCheckPacket)PacketPool.Instance.GetPacket(PacketType.StartPingCheck);
+            pc.Header.Reliable = false;
+
+            pc.PingID.PingID = (byte)udpClient.CurrentPingSequence++;
+            // We *could* get OldestUnacked, but it would hurt performance and not provide any benefit
+            pc.PingID.OldestUnacked = 0;
+
+            SendPacket(udpClient, pc, ThrottleOutPacketType.Unknown, false, null);
+            udpClient.m_lastStartpingTimeMS = Util.EnvironmentTickCount();
+        }
+
+        public void CompletePing(LLUDPClient udpClient, byte pingID)
+        {
+            CompletePingCheckPacket completePing = new CompletePingCheckPacket();
+            completePing.PingID.PingID = pingID;
+            SendPacket(udpClient, completePing, ThrottleOutPacketType.Unknown, false, null);
+        }
+
+        public void HandleUnacked(LLClientView client)
+        {
+            LLUDPClient udpClient = client.UDPClient;
+
+            if (!udpClient.IsConnected)
+                return;
+
+            // Disconnect an agent if no packets are received for some time
+            int timeoutTicks = m_ackTimeout;
+
+            // Allow more slack if the client is "paused" eg file upload dialogue is open
+            // Some sort of limit is needed in case the client crashes, loses its network connection
+            // or some other disaster prevents it from sendung the AgentResume
+            if (udpClient.IsPaused)
+                timeoutTicks = m_pausedAckTimeout;
+
+            if (client.IsActive &&
+                (Environment.TickCount & Int32.MaxValue) - udpClient.TickLastPacketReceived > timeoutTicks)
+            {
+                // We must set IsActive synchronously so that we can stop the packet loop reinvoking this method, even
+                // though it's set later on by LLClientView.Close()
+                client.IsActive = false;
+
+                // Fire this out on a different thread so that we don't hold up outgoing packet processing for
+                // everybody else if this is being called due to an ack timeout.
+                // This is the same as processing as the async process of a logout request.
+                Util.FireAndForget(
+                    o => DeactivateClientDueToTimeout(client, timeoutTicks), null, "LLUDPServer.DeactivateClientDueToTimeout");
+
+                return;
+            }
+
+            // Get a list of all of the packets that have been sitting unacked longer than udpClient.RTO
+            List<OutgoingPacket> expiredPackets = udpClient.NeedAcks.GetExpiredPackets(udpClient.RTO);
+
+            if (expiredPackets != null)
+            {
+                //m_log.Debug("[LLUDPSERVER]: Handling " + expiredPackets.Count + " packets to " + udpClient.AgentID + ", RTO=" + udpClient.RTO);
+                // Exponential backoff of the retransmission timeout
+                udpClient.BackoffRTO();
+                for (int i = 0; i < expiredPackets.Count; ++i)
+                    expiredPackets[i].UnackedMethod(expiredPackets[i]);
+            }
+        }
+
+        public void ResendUnacked(OutgoingPacket outgoingPacket)
+        {
+            //m_log.DebugFormat("[LLUDPSERVER]: Resending packet #{0} (attempt {1}), {2}ms have passed",
+            //    outgoingPacket.SequenceNumber, outgoingPacket.ResendCount, Environment.TickCount - outgoingPacket.TickCount);
+
+            // Set the resent flag
+            outgoingPacket.Buffer.Data[0] = (byte)(outgoingPacket.Buffer.Data[0] | Helpers.MSG_RESENT);
+            outgoingPacket.Category = ThrottleOutPacketType.Resend;
+
+            // Bump up the resend count on this packet
+            Interlocked.Increment(ref outgoingPacket.ResendCount);
+
+            // Requeue or resend the packet
+            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket, false))
+                SendPacketFinal(outgoingPacket);
+        }
+
+        public void Flush(LLUDPClient udpClient)
+        {
+            // FIXME: Implement?
+        }
+
+        /// <summary>
+        /// Actually send a packet to a client.
+        /// </summary>
+        /// <param name="outgoingPacket"></param>
+        internal void SendPacketFinal(OutgoingPacket outgoingPacket)
+        {
+            UDPPacketBuffer buffer = outgoingPacket.Buffer;
+            byte flags = buffer.Data[0];
+            bool isResend = (flags & Helpers.MSG_RESENT) != 0;
+            bool isReliable = (flags & Helpers.MSG_RELIABLE) != 0;
+            bool isZerocoded = (flags & Helpers.MSG_ZEROCODED) != 0;
+            LLUDPClient udpClient = outgoingPacket.Client;
+
+            if (!udpClient.IsConnected)
+                return;
+
+            #region ACK Appending
+
+            int dataLength = buffer.DataLength;
+
+            // NOTE: I'm seeing problems with some viewers when ACKs are appended to zerocoded packets so I've disabled that here
+            if (!isZerocoded && !isResend && outgoingPacket.UnackedMethod == null)
+            {
+                // Keep appending ACKs until there is no room left in the buffer or there are
+                // no more ACKs to append
+                uint ackCount = 0;
+                uint ack;
+                while (dataLength + 5 < buffer.Data.Length && udpClient.PendingAcks.Dequeue(out ack))
+                {
+                    Utils.UIntToBytesBig(ack, buffer.Data, dataLength);
+                    dataLength += 4;
+                    ++ackCount;
+                }
+
+                if (ackCount > 0)
+                {
+                    // Set the last byte of the packet equal to the number of appended ACKs
+                    buffer.Data[dataLength++] = (byte)ackCount;
+                    // Set the appended ACKs flag on this packet
+                    buffer.Data[0] = (byte)(buffer.Data[0] | Helpers.MSG_APPENDED_ACKS);
+                }
+            }
+
+            buffer.DataLength = dataLength;
+
+            #endregion ACK Appending
+
+            #region Sequence Number Assignment
+
+            if (!isResend)
+            {
+                // Not a resend, assign a new sequence number
+                uint sequenceNumber = (uint)Interlocked.Increment(ref udpClient.CurrentSequence);
+                Utils.UIntToBytesBig(sequenceNumber, buffer.Data, 1);
+                outgoingPacket.SequenceNumber = sequenceNumber;
+
+                if (isReliable)
+                {
+                    // Add this packet to the list of ACK responses we are waiting on from the server
+                    udpClient.NeedAcks.Add(outgoingPacket);
+                }
+            }
+            else
+            {
+                Interlocked.Increment(ref udpClient.PacketsResent);
+
+                // We're not going to worry about interlock yet since its not currently critical that this total count
+                // is 100% correct
+                PacketsResentCount++;
+            }
+
+            #endregion Sequence Number Assignment
+
+            // Stats tracking
+            Interlocked.Increment(ref udpClient.PacketsSent);
+
+            // We're not going to worry about interlock yet since its not currently critical that this total count
+            // is 100% correct
+            PacketsSentCount++;
+
+            if (udpClient.DebugDataOutLevel > 0)
+                m_log.DebugFormat(
+                    "[LLUDPSERVER]: Sending packet #{0} (rel: {1}, res: {2}) to {3} from {4}",
+                    outgoingPacket.SequenceNumber, isReliable, isResend, udpClient.AgentID, Scene.Name);
+
+            // Put the UDP payload on the wire
+//            AsyncBeginSend(buffer);
+            SyncSend(buffer);
+
+            // Keep track of when this packet was sent out (right now)
+            outgoingPacket.TickCount = Environment.TickCount & Int32.MaxValue;
+        }
+
+        protected void RecordMalformedInboundPacket(IPEndPoint endPoint)
+        {
+//                if (m_malformedCount < 100)
+//                    m_log.DebugFormat("[LLUDPSERVER]: Dropped malformed packet: " + e.ToString());
+
+            IncomingMalformedPacketCount++;
+
+            if ((IncomingMalformedPacketCount % 10000) == 0)
+                m_log.WarnFormat(
+                    "[LLUDPSERVER]: Received {0} malformed packets so far, probable network attack.  Last was from {1}",
+                    IncomingMalformedPacketCount, endPoint);
+        }
+
+        public override void PacketReceived(UDPPacketBuffer buffer)
+        {
+            // Debugging/Profiling
+            //try { Thread.CurrentThread.Name = "PacketReceived (" + m_scene.RegionInfo.RegionName + ")"; }
+            //catch (Exception) { }
+//            m_log.DebugFormat(
+//                "[LLUDPSERVER]: Packet received from {0} in {1}", buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
+
+            LLUDPClient udpClient = null;
+            Packet packet = null;
+            int packetEnd = buffer.DataLength - 1;
+            IPEndPoint endPoint = (IPEndPoint)buffer.RemoteEndPoint;
+
+            #region Decoding
+
+            if (buffer.DataLength < 7)
+            {
+//                m_log.WarnFormat(
+//                    "[LLUDPSERVER]: Dropping undersized packet with {0} bytes received from {1} in {2}",
+//                    buffer.DataLength, buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
+
+                RecordMalformedInboundPacket(endPoint);
+
+                return; // Drop undersized packet
+            }
+
+            int headerLen = 7;
+            if (buffer.Data[6] == 0xFF)
+            {
+                if (buffer.Data[7] == 0xFF)
+                    headerLen = 10;
+                else
+                    headerLen = 8;
+            }
+
+            if (buffer.DataLength < headerLen)
+            {
+//                m_log.WarnFormat(
+//                    "[LLUDPSERVER]: Dropping packet with malformed header received from {0} in {1}",
+//                    buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
+
+                RecordMalformedInboundPacket(endPoint);
+
+                return; // Malformed header
+            }
+
+            try
+            {
+//                packet = Packet.BuildPacket(buffer.Data, ref packetEnd,
+//                    // Only allocate a buffer for zerodecoding if the packet is zerocoded
+//                    ((buffer.Data[0] & Helpers.MSG_ZEROCODED) != 0) ? new byte[4096] : null);
+                // If OpenSimUDPBase.UsePool == true (which is currently separate from the PacketPool) then we
+                // assume that packet construction does not retain a reference to byte[] buffer.Data (instead, all
+                // bytes are copied out).
+                packet = PacketPool.Instance.GetPacket(buffer.Data, ref packetEnd,
+                    // Only allocate a buffer for zerodecoding if the packet is zerocoded
+                    ((buffer.Data[0] & Helpers.MSG_ZEROCODED) != 0) ? new byte[4096] : null);
+            }
+            catch (Exception e)
+            {
+                if (IncomingMalformedPacketCount < 100)
+                    m_log.DebugFormat("[LLUDPSERVER]: Dropped malformed packet: " + e.ToString());
+            }
+
+            // Fail-safe check
+            if (packet == null)
+            {
+                if (IncomingMalformedPacketCount < 100)
+                {
+                    m_log.WarnFormat("[LLUDPSERVER]: Malformed data, cannot parse {0} byte packet from {1}, data as hex {2}:  {3}",
+                        buffer.DataLength, buffer.RemoteEndPoint, Utils.BytesToHexString(buffer.Data, buffer.DataLength, null),
+                        Regex.Replace(Encoding.UTF8.GetString(buffer.Data, 0, buffer.DataLength), @"\p{Cc}", a=>string.Format("[{0:X2}]", (byte)a.Value[0])));
+                }
+
+                RecordMalformedInboundPacket(endPoint);
+
+                return;
+            }
+
+            #endregion Decoding
+
+            #region Packet to Client Mapping
+
+            // If there is already a client for this endpoint, don't process UseCircuitCode
+            IClientAPI client = null;
+            if (!Scene.TryGetClient(endPoint, out client) || !(client is LLClientView))
+            {
+                // UseCircuitCode handling
+                if (packet.Type == PacketType.UseCircuitCode)
+                {
+                    // And if there is a UseCircuitCode pending, also drop it
+                    lock (m_pendingCache)
+                    {
+                        if (m_pendingCache.Contains(endPoint))
+                            return;
+
+                        m_pendingCache.AddOrUpdate(endPoint, new Queue<UDPPacketBuffer>(), 60);
+                    }
+
+                    // We need to copy the endpoint so that it doesn't get changed when another thread reuses the
+                    // buffer.
+                    object[] array = new object[] { new IPEndPoint(endPoint.Address, endPoint.Port), packet };
+
+                    Util.FireAndForget(HandleUseCircuitCode, array);
+
+                    return;
+                }
+            }
+
+            // If this is a pending connection, enqueue, don't process yet
+            lock (m_pendingCache)
+            {
+                Queue<UDPPacketBuffer> queue;
+                if (m_pendingCache.TryGetValue(endPoint, out queue))
+                {
+                    //m_log.DebugFormat("[LLUDPSERVER]: Enqueued a {0} packet into the pending queue", packet.Type);
+                    queue.Enqueue(buffer);
+                    return;
+                }
+
+/*
+                else if (packet.Type == PacketType.CompleteAgentMovement)
+                {
+                    // Send ack straight away to let the viewer know that we got it.
+                    SendAckImmediate(endPoint, packet.Header.Sequence);
+
+                    // We need to copy the endpoint so that it doesn't get changed when another thread reuses the
+                    // buffer.
+                    object[] array = new object[] { new IPEndPoint(endPoint.Address, endPoint.Port), packet };
+
+                    Util.FireAndForget(HandleCompleteMovementIntoRegion, array);
+
+                    return;
+                }
+ */
+            }
+
+            // Determine which agent this packet came from
+            if (client == null || !(client is LLClientView))
+            {
+                //m_log.Debug("[LLUDPSERVER]: Received a " + packet.Type + " packet from an unrecognized source: " + address + " in " + m_scene.RegionInfo.RegionName);
+
+                IncomingOrphanedPacketCount++;
+
+                if ((IncomingOrphanedPacketCount % 10000) == 0)
+                    m_log.WarnFormat(
+                        "[LLUDPSERVER]: Received {0} orphaned packets so far.  Last was from {1}",
+                        IncomingOrphanedPacketCount, endPoint);
+
+                return;
+            }
+
+            udpClient = ((LLClientView)client).UDPClient;
+
+            if (!udpClient.IsConnected)
+            {
+                m_log.Debug("[LLUDPSERVER]: Received a " + packet.Type + " packet for a unConnected client in " + Scene.RegionInfo.RegionName);
+                return;
+            }
+
+            #endregion Packet to Client Mapping
+
+            // Stats tracking
+            Interlocked.Increment(ref udpClient.PacketsReceived);
+
+            int now = Environment.TickCount & Int32.MaxValue;
+            udpClient.TickLastPacketReceived = now;
+
+            #region ACK Receiving
+
+            // Handle appended ACKs
+            if (packet.Header.AppendedAcks && packet.Header.AckList != null)
+            {
+                // m_log.DebugFormat(
+                //      "[LLUDPSERVER]: Handling {0} appended acks from {1} in {2}",
+                //      packet.Header.AckList.Length, client.Name, m_scene.Name);
+
+                for (int i = 0; i < packet.Header.AckList.Length; i++)
+                    udpClient.NeedAcks.Acknowledge(packet.Header.AckList[i], now, packet.Header.Resent);
+            }
+
+            // Handle PacketAck packets
+            if (packet.Type == PacketType.PacketAck)
+            {
+                PacketAckPacket ackPacket = (PacketAckPacket)packet;
+
+                // m_log.DebugFormat(
+                //      "[LLUDPSERVER]: Handling {0} packet acks for {1} in {2}",
+                //      ackPacket.Packets.Length, client.Name, m_scene.Name);
+
+                for (int i = 0; i < ackPacket.Packets.Length; i++)
+                    udpClient.NeedAcks.Acknowledge(ackPacket.Packets[i].ID, now, packet.Header.Resent);
+
+                // We don't need to do anything else with PacketAck packets
+                return;
+            }
+
+            #endregion ACK Receiving
+
+            #region ACK Sending
+
+            if (packet.Header.Reliable)
+            {
+//                m_log.DebugFormat(
+//                    "[LLUDPSERVER]: Adding ack request for {0} {1} from {2} in {3}",
+//                    packet.Type, packet.Header.Sequence, client.Name, m_scene.Name);
+
+                udpClient.PendingAcks.Enqueue(packet.Header.Sequence);
+
+                // This is a somewhat odd sequence of steps to pull the client.BytesSinceLastACK value out,
+                // add the current received bytes to it, test if 2*MTU bytes have been sent, if so remove
+                // 2*MTU bytes from the value and send ACKs, and finally add the local value back to
+                // client.BytesSinceLastACK. Lockless thread safety
+                int bytesSinceLastACK = Interlocked.Exchange(ref udpClient.BytesSinceLastACK, 0);
+                bytesSinceLastACK += buffer.DataLength;
+                if (bytesSinceLastACK > LLUDPServer.MTU * 2)
+                {
+                    bytesSinceLastACK -= LLUDPServer.MTU * 2;
+                    SendAcks(udpClient);
+                }
+                Interlocked.Add(ref udpClient.BytesSinceLastACK, bytesSinceLastACK);
+            }
+
+            #endregion ACK Sending
+
+            #region Incoming Packet Accounting
+
+            // We're not going to worry about interlock yet since its not currently critical that this total count
+            // is 100% correct
+            if (packet.Header.Resent)
+                IncomingPacketsResentCount++;
+
+            // Check the archive of received reliable packet IDs to see whether we already received this packet
+            if (packet.Header.Reliable && !udpClient.PacketArchive.TryEnqueue(packet.Header.Sequence))
+            {
+                if (packet.Header.Resent)
+                    m_log.DebugFormat(
+                        "[LLUDPSERVER]: Received a resend of already processed packet #{0}, type {1} from {2}",
+                        packet.Header.Sequence, packet.Type, client.Name);
+                 else
+                    m_log.WarnFormat(
+                        "[LLUDPSERVER]: Received a duplicate (not marked as resend) of packet #{0}, type {1} from {2}",
+                        packet.Header.Sequence, packet.Type, client.Name);
+
+                // Avoid firing a callback twice for the same packet
+                return;
+            }
+
+            #endregion Incoming Packet Accounting
+
+            #region BinaryStats
+            LogPacketHeader(true, udpClient.CircuitCode, 0, packet.Type, (ushort)packet.Length);
+            #endregion BinaryStats
+
+
+//AgentUpdate removed from here
+
+
+            #region Ping Check Handling
+
+            if (packet.Type == PacketType.StartPingCheck)
+            {
+//                m_log.DebugFormat("[LLUDPSERVER]: Handling ping from {0} in {1}", client.Name, m_scene.Name);
+
+                // We don't need to do anything else with ping checks
+                StartPingCheckPacket startPing = (StartPingCheckPacket)packet;
+                CompletePing(udpClient, startPing.PingID.PingID);
+
+                if ((Environment.TickCount - m_elapsedMSSinceLastStatReport) >= 3000)
+                {
+                    udpClient.SendPacketStats();
+                    m_elapsedMSSinceLastStatReport = Environment.TickCount;
+                }
+                return;
+            }
+            else if (packet.Type == PacketType.CompletePingCheck)
+            {
+                int t = Util.EnvironmentTickCountSubtract(udpClient.m_lastStartpingTimeMS);
+                int c = udpClient.m_pingMS;
+                c = 800 * c + 200 * t;
+                c /= 1000;
+                udpClient.m_pingMS = c;
+                return;
+            }
+
+            #endregion Ping Check Handling
+
+            IncomingPacket incomingPacket;
+
+            // Inbox insertion
+            if (UsePools)
+            {
+                incomingPacket = m_incomingPacketPool.GetObject();
+                incomingPacket.Client = (LLClientView)client;
+                incomingPacket.Packet = packet;
+            }
+            else
+            {
+                incomingPacket = new IncomingPacket((LLClientView)client, packet);
+            }
+
+//            if (incomingPacket.Packet.Type == PacketType.AgentUpdate ||
+//                incomingPacket.Packet.Type == PacketType.ChatFromViewer)
+            if (incomingPacket.Packet.Type == PacketType.ChatFromViewer)
+                packetInbox.PriorityEnqueue(incomingPacket);
+            else
+                packetInbox.Enqueue(incomingPacket);
+
+        }
+
+        #region BinaryStats
+
+        public class PacketLogger
+        {
+            public DateTime StartTime;
+            public string Path = null;
+            public System.IO.BinaryWriter Log = null;
+        }
+
+        public static PacketLogger PacketLog;
+
+        protected static bool m_shouldCollectStats = false;
+        // Number of seconds to log for
+        static TimeSpan binStatsMaxFilesize = TimeSpan.FromSeconds(300);
+        static object binStatsLogLock = new object();
+        static string binStatsDir = "";
+
+        //for Aggregated In/Out BW logging
+        static bool m_aggregatedBWStats = false;
+        static long m_aggregatedBytesIn = 0;
+        static long m_aggregatedByestOut = 0;
+        static object aggBWStatsLock = new object();
+
+        public static long AggregatedLLUDPBytesIn
+        {
+            get { return m_aggregatedBytesIn; }
+        }
+        public static long AggregatedLLUDPBytesOut
+        {
+            get {return m_aggregatedByestOut;}
+        }
+
+        public static void LogPacketHeader(bool incoming, uint circuit, byte flags, PacketType packetType, ushort size)
+        {
+            if (m_aggregatedBWStats)
+            {
+                lock (aggBWStatsLock)
+                {
+                    if (incoming)
+                        m_aggregatedBytesIn += size;
+                    else
+                        m_aggregatedByestOut += size;
+                }
+            }
+
+            if (!m_shouldCollectStats) return;
+
+            // Binary logging format is TTTTTTTTCCCCFPPPSS, T=Time, C=Circuit, F=Flags, P=PacketType, S=size
+
+            // Put the incoming bit into the least significant bit of the flags byte
+            if (incoming)
+                flags |= 0x01;
+            else
+                flags &= 0xFE;
+
+            // Put the flags byte into the most significant bits of the type integer
+            uint type = (uint)packetType;
+            type |= (uint)flags << 24;
+
+            // m_log.Debug("1 LogPacketHeader(): Outside lock");
+            lock (binStatsLogLock)
+            {
+                DateTime now = DateTime.Now;
+
+                // m_log.Debug("2 LogPacketHeader(): Inside lock. now is " + now.Ticks);
+                try
+                {
+                    if (PacketLog == null || (now > PacketLog.StartTime + binStatsMaxFilesize))
+                    {
+                        if (PacketLog != null && PacketLog.Log != null)
+                        {
+                            PacketLog.Log.Close();
+                        }
+
+                        // First log file or time has expired, start writing to a new log file
+                        PacketLog = new PacketLogger();
+                        PacketLog.StartTime = now;
+                        PacketLog.Path = (binStatsDir.Length > 0 ? binStatsDir + System.IO.Path.DirectorySeparatorChar.ToString() : "")
+                                + String.Format("packets-{0}.log", now.ToString("yyyyMMddHHmmss"));
+                        PacketLog.Log = new BinaryWriter(File.Open(PacketLog.Path, FileMode.Append, FileAccess.Write));
+                    }
+
+                    // Serialize the data
+                    byte[] output = new byte[18];
+                    Buffer.BlockCopy(BitConverter.GetBytes(now.Ticks), 0, output, 0, 8);
+                    Buffer.BlockCopy(BitConverter.GetBytes(circuit), 0, output, 8, 4);
+                    Buffer.BlockCopy(BitConverter.GetBytes(type), 0, output, 12, 4);
+                    Buffer.BlockCopy(BitConverter.GetBytes(size), 0, output, 16, 2);
+
+                    // Write the serialized data to disk
+                    if (PacketLog != null && PacketLog.Log != null)
+                        PacketLog.Log.Write(output);
+                }
+                catch (Exception ex)
+                {
+                    m_log.Error("Packet statistics gathering failed: " + ex.Message, ex);
+                    if (PacketLog.Log != null)
+                    {
+                        PacketLog.Log.Close();
+                    }
+                    PacketLog = null;
+                }
+            }
+        }
+
+        #endregion BinaryStats
+
+        protected void HandleUseCircuitCode(object o)
+        {
+            IPEndPoint endPoint = null;
+            IClientAPI client = null;
+
+            try
+            {
+//              DateTime startTime = DateTime.Now;
+                object[] array = (object[])o;
+                endPoint = (IPEndPoint)array[0];
+                UseCircuitCodePacket uccp = (UseCircuitCodePacket)array[1];
+
+                m_log.DebugFormat(
+                    "[LLUDPSERVER]: Handling UseCircuitCode request for circuit {0} to {1} from IP {2}",
+                    uccp.CircuitCode.Code, Scene.RegionInfo.RegionName, endPoint);
+
+                AuthenticateResponse sessionInfo;
+                if (IsClientAuthorized(uccp, out sessionInfo))
+                {
+                    AgentCircuitData aCircuit = Scene.AuthenticateHandler.GetAgentCircuitData(uccp.CircuitCode.Code);
+
+                    // Begin the process of adding the client to the simulator
+                    client
+                        = AddClient(
+                            uccp.CircuitCode.Code,
+                            uccp.CircuitCode.ID,
+                            uccp.CircuitCode.SessionID,
+                            endPoint,
+                            sessionInfo);
+
+                    // This will be true if the client is new, e.g. not
+                    // an existing child agent, and there is no circuit data
+                    if (client != null && aCircuit == null)
+                    {
+                        Scene.CloseAgent(client.AgentId, true);
+                        return;
+                    }
+
+                    // Now we know we can handle more data
+                    Thread.Sleep(200);
+
+                    // Obtain the pending queue and remove it from the cache
+                    Queue<UDPPacketBuffer> queue = null;
+
+                    lock (m_pendingCache)
+                    {
+                        if (!m_pendingCache.TryGetValue(endPoint, out queue))
+                        {
+                            m_log.DebugFormat("[LLUDPSERVER]: Client created but no pending queue present");
+                            return;
+
+                        }
+                        m_pendingCache.Remove(endPoint);
+                    }
+
+                    m_log.DebugFormat("[LLUDPSERVER]: Client created, processing pending queue, {0} entries", queue.Count);
+
+                    // Reinject queued packets
+                    while (queue.Count > 0)
+                    {
+                        UDPPacketBuffer buf = queue.Dequeue();
+                        PacketReceived(buf);
+                    }
+
+                    queue = null;
+
+                    // Send ack straight away to let the viewer know that the connection is active.
+                    // The client will be null if it already exists (e.g. if on a region crossing the client sends a use
+                    // circuit code to the existing child agent.  This is not particularly obvious.
+                    SendAckImmediate(endPoint, uccp.Header.Sequence);
+
+                    // We only want to send initial data to new clients, not ones which are being converted from child to root.
+                    if (client != null)
+                    {
+                        bool tp = (aCircuit.teleportFlags > 0);
+                        // Let's delay this for TP agents, otherwise the viewer doesn't know where to get resources from
+                        if (!tp)
+                            client.SceneAgent.SendInitialDataToMe();
+                    }
+                }
+                else
+                {
+                    // Don't create clients for unauthorized requesters.
+                    m_log.WarnFormat(
+                        "[LLUDPSERVER]: Ignoring connection request for {0} to {1} with unknown circuit code {2} from IP {3}",
+
+                        uccp.CircuitCode.ID, Scene.RegionInfo.RegionName, uccp.CircuitCode.Code, endPoint);
+
+                    lock (m_pendingCache)
+                        m_pendingCache.Remove(endPoint);
+                }
+
+                //            m_log.DebugFormat(
+    //                "[LLUDPSERVER]: Handling UseCircuitCode request from {0} took {1}ms",
+    //                buffer.RemoteEndPoint, (DateTime.Now - startTime).Milliseconds);
+
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat(
+                    "[LLUDPSERVER]: UseCircuitCode handling from endpoint {0}, client {1} {2} failed.  Exception {3}{4}",
+                    endPoint != null ? endPoint.ToString() : "n/a",
+                    client != null ? client.Name : "unknown",
+                    client != null ? client.AgentId.ToString() : "unknown",
+                    e.Message,
+                    e.StackTrace);
+            }
+        }
+/*
+         protected void HandleCompleteMovementIntoRegion(object o)
+        {
+            IPEndPoint endPoint = null;
+            IClientAPI client = null;
+
+            try
+            {
+                object[] array = (object[])o;
+                endPoint = (IPEndPoint)array[0];
+                CompleteAgentMovementPacket packet = (CompleteAgentMovementPacket)array[1];
+
+                m_log.DebugFormat(
+                    "[LLUDPSERVER]: Handling CompleteAgentMovement request from {0} in {1}", endPoint, Scene.Name);
+
+                // Determine which agent this packet came from
+                // We need to wait here because in when using the OpenSimulator V2 teleport protocol to travel to a destination
+                // simulator with no existing child presence, the viewer (at least LL 3.3.4) will send UseCircuitCode
+                // and then CompleteAgentMovement immediately without waiting for an ack.  As we are now handling these
+                // packets asynchronously, we need to account for this thread proceeding more quickly than the
+                // UseCircuitCode thread.
+                int count = 40;
+                while (count-- > 0)
+                {
+                    if (Scene.TryGetClient(endPoint, out client))
+                    {
+                        if (!client.IsActive)
+                        {
+                            // This check exists to catch a condition where the client has been closed by another thread
+                            // but has not yet been removed from the client manager (and possibly a new connection has
+                            // not yet been established).
+                            m_log.DebugFormat(
+                                "[LLUDPSERVER]: Received a CompleteAgentMovement from {0} for {1} in {2} but client is not active yet.  Waiting.",
+                                endPoint, client.Name, Scene.Name);
+                        }
+                        else if (client.SceneAgent == null)
+                        {
+                            // This check exists to catch a condition where the new client has been added to the client
+                            // manager but the SceneAgent has not yet been set in Scene.AddNewAgent().  If we are too
+                            // eager, then the new ScenePresence may not have registered a listener for this messsage
+                            // before we try to process it.
+                            // XXX: A better long term fix may be to add the SceneAgent before the client is added to
+                            // the client manager
+                            m_log.DebugFormat(
+                                "[LLUDPSERVER]: Received a CompleteAgentMovement from {0} for {1} in {2} but client SceneAgent not set yet.  Waiting.",
+                                endPoint, client.Name, Scene.Name);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        m_log.DebugFormat(
+                            "[LLUDPSERVER]: Received a CompleteAgentMovement from {0} in {1} but no client exists yet.  Waiting.",
+                            endPoint, Scene.Name);
+                    }
+
+                    Thread.Sleep(200);
+                }
+
+                if (client == null)
+                {
+                    m_log.DebugFormat(
+                        "[LLUDPSERVER]: No client found for CompleteAgentMovement from {0} in {1} after wait.  Dropping.",
+                        endPoint, Scene.Name);
+
+                    return;
+                }
+                else if (!client.IsActive || client.SceneAgent == null)
+                {
+                    // This check exists to catch a condition where the client has been closed by another thread
+                    // but has not yet been removed from the client manager.
+                    // The packet could be simply ignored but it is useful to know if this condition occurred for other debugging
+                    // purposes.
+                    m_log.DebugFormat(
+                        "[LLUDPSERVER]: Received a CompleteAgentMovement from {0} for {1} in {2} but client is not active after wait.  Dropping.",
+                        endPoint, client.Name, Scene.Name);
+
+                    return;
+                }
+
+                IncomingPacket incomingPacket1;
+
+                // Inbox insertion
+                if (UsePools)
+                {
+                    incomingPacket1 = m_incomingPacketPool.GetObject();
+                    incomingPacket1.Client = (LLClientView)client;
+                    incomingPacket1.Packet = packet;
+                }
+                else
+                {
+                    incomingPacket1 = new IncomingPacket((LLClientView)client, packet);
+                }
+
+                packetInbox.Enqueue(incomingPacket1);
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat(
+                    "[LLUDPSERVER]: CompleteAgentMovement handling from endpoint {0}, client {1} {2} failed.  Exception {3}{4}",
+                    endPoint != null ? endPoint.ToString() : "n/a",
+                    client != null ? client.Name : "unknown",
+                    client != null ? client.AgentId.ToString() : "unknown",
+                    e.Message,
+                    e.StackTrace);
+            }
+        }
+*/
+
+        /// <summary>
+        /// Send an ack immediately to the given endpoint.
+        /// </summary>
+        /// <remarks>
+        /// FIXME: Might be possible to use SendPacketData() like everything else, but this will require refactoring so
+        /// that we can obtain the UDPClient easily at this point.
+        /// </remarks>
+        /// <param name="remoteEndpoint"></param>
+        /// <param name="sequenceNumber"></param>
+        protected void SendAckImmediate(IPEndPoint remoteEndpoint, uint sequenceNumber)
+        {
+            PacketAckPacket ack = new PacketAckPacket();
+            ack.Header.Reliable = false;
+            ack.Packets = new PacketAckPacket.PacketsBlock[1];
+            ack.Packets[0] = new PacketAckPacket.PacketsBlock();
+            ack.Packets[0].ID = sequenceNumber;
+
+            SendAckImmediate(remoteEndpoint, ack);
+        }
+
+        public virtual void SendAckImmediate(IPEndPoint remoteEndpoint, PacketAckPacket ack)
+        {
+            byte[] packetData = ack.ToBytes();
+            int length = packetData.Length;
+
+            UDPPacketBuffer buffer = new UDPPacketBuffer(remoteEndpoint, length);
+            buffer.DataLength = length;
+
+            Buffer.BlockCopy(packetData, 0, buffer.Data, 0, length);
+
+//            AsyncBeginSend(buffer);
+            SyncSend(buffer);
+        }
+
+        protected bool IsClientAuthorized(UseCircuitCodePacket useCircuitCode, out AuthenticateResponse sessionInfo)
+        {
+            UUID agentID = useCircuitCode.CircuitCode.ID;
+            UUID sessionID = useCircuitCode.CircuitCode.SessionID;
+            uint circuitCode = useCircuitCode.CircuitCode.Code;
+
+            sessionInfo = m_circuitManager.AuthenticateSession(sessionID, agentID, circuitCode);
+            return sessionInfo.Authorised;
+        }
+
+        /// <summary>
+        /// Add a client.
+        /// </summary>
+        /// <param name="circuitCode"></param>
+        /// <param name="agentID"></param>
+        /// <param name="sessionID"></param>
+        /// <param name="remoteEndPoint"></param>
+        /// <param name="sessionInfo"></param>
+        /// <returns>The client if it was added.  Null if the client already existed.</returns>
+        protected virtual IClientAPI AddClient(
+            uint circuitCode, UUID agentID, UUID sessionID, IPEndPoint remoteEndPoint, AuthenticateResponse sessionInfo)
+        {
+            IClientAPI client = null;
+            bool createNew = false;
+
+            // We currently synchronize this code across the whole scene to avoid issues such as
+            // http://opensimulator.org/mantis/view.php?id=5365  However, once locking per agent circuit can be done
+            // consistently, this lock could probably be removed.
+            lock (this)
+            {
+                if (!Scene.TryGetClient(agentID, out client))
+                {
+                    createNew = true;
+                }
+                else
+                {
+                    if (client.SceneAgent == null)
+                    {
+                        Scene.CloseAgent(agentID, true);
+                        createNew = true;
+                    }
+                }
+
+                if (createNew)
+                {
+                    LLUDPClient udpClient = new LLUDPClient(this, ThrottleRates, Throttle, circuitCode, agentID, remoteEndPoint, m_defaultRTO, m_maxRTO);
+
+
+                    client = new LLClientView(Scene, this, udpClient, sessionInfo, agentID, sessionID, circuitCode);
+                    client.OnLogout += LogoutHandler;
+                    client.DebugPacketLevel = DefaultClientPacketDebugLevel;
+
+                    ((LLClientView)client).DisableFacelights = m_disableFacelights;
+
+                    client.Start();
+                }
+            }
+
+            return client;
+        }
+
+        /// <summary>
+        /// Deactivates the client if we don't receive any packets within a certain amount of time (default 60 seconds).
+        /// </summary>
+        /// <remarks>
+        /// If a connection is active then we will always receive packets even if nothing else is happening, due to
+        /// regular client pings.
+        /// </remarks>
+        /// <param name='client'></param>
+        /// <param name='timeoutTicks'></param>
+        protected void DeactivateClientDueToTimeout(LLClientView client, int timeoutTicks)
+        {
+            lock (client.CloseSyncLock)
+            {
+                ClientLogoutsDueToNoReceives++;
+
+                if (client.SceneAgent != null)
+                {
+                    m_log.WarnFormat(
+                        "[LLUDPSERVER]: No packets received from {0} agent of {1} for {2}ms in {3}.  Disconnecting.",
+                        client.SceneAgent.IsChildAgent ? "child" : "root", client.Name, timeoutTicks, Scene.Name);
+
+                    if (!client.SceneAgent.IsChildAgent)
+                         client.Kick("Simulator logged you out due to connection timeout.");
+                }
+            }
+
+            if (!Scene.CloseAgent(client.AgentId, true))
+                client.Close(true,true);
+        }
+
+        protected void IncomingPacketHandler()
+        {
+            Thread.CurrentThread.Priority = ThreadPriority.Highest;
+            IncomingPacket incomingPacket;
+            // Set this culture for the thread that incoming packets are received
+            // on to en-US to avoid number parsing issues
+            Culture.SetCurrentCulture();
+
+            while (IsRunningInbound)
+            {
+                Scene.ThreadAlive(1);
+                try
+                {
+                    incomingPacket = packetInbox.Dequeue(250);
+
+                    if (incomingPacket != null && IsRunningInbound)
+                    {
+                        ProcessInPacket(incomingPacket);
+
+                        if (UsePools)
+                        {
+                            incomingPacket.Client = null;
+                            m_incomingPacketPool.ReturnObject(incomingPacket);
+                        }
+                        incomingPacket = null;
+                    }
+                }
+                catch(Exception ex)
+                {
+                    m_log.Error("[LLUDPSERVER]: Error in the incoming packet handler loop: " + ex.Message, ex);
+                }
+
+                Watchdog.UpdateThread();
+            }
+
+            if (packetInbox.Count() > 0)
+                m_log.Warn("[LLUDPSERVER]: IncomingPacketHandler is shutting down, dropping " + packetInbox.Count() + " packets");
+            packetInbox.Clear();
+
+            Watchdog.RemoveThread();
+        }
+
+        protected void OutgoingPacketHandler()
+        {
+            Thread.CurrentThread.Priority = ThreadPriority.Highest;
+
+            // Set this culture for the thread that outgoing packets are sent
+            // on to en-US to avoid number parsing issues
+            Culture.SetCurrentCulture();
+
+            // Typecast the function to an Action<IClientAPI> once here to avoid allocating a new
+            // Action generic every round
+            Action<IClientAPI> clientPacketHandler = ClientOutgoingPacketHandler;
+
+            while (base.IsRunningOutbound)
+            {
+                Scene.ThreadAlive(2);
+
+
+                try
+                {
+                    m_packetSent = false;
+
+                    #region Update Timers
+
+                    m_resendUnacked = false;
+                    m_sendAcks = false;
+                    m_sendPing = false;
+
+                    // Update elapsed time
+                    double thisTick = Util.GetTimeStampMS();
+
+                    // update some 1ms resolution chained timers
+                    m_elapsedMSOutgoingPacketHandler +=  thisTick - m_tickLastOutgoingPacketHandler;
+                    m_tickLastOutgoingPacketHandler = thisTick;
+
+                    // Check for pending outgoing resends every 100ms
+                    if (m_elapsedMSOutgoingPacketHandler >= 100.0)
+                    {
+                        m_resendUnacked = true;
+                        m_elapsedMSOutgoingPacketHandler = 0.0;
+                        m_elapsed100MSOutgoingPacketHandler += 1;
+                    }
+
+                    // Check for pending outgoing ACKs every 500ms
+                    if (m_elapsed100MSOutgoingPacketHandler >= 5)
+                    {
+                        m_sendAcks = true;
+                        m_elapsed100MSOutgoingPacketHandler = 0;
+                        m_elapsed500MSOutgoingPacketHandler += 1;
+                    }
+
+                    // Send pings to clients every 5000ms
+                    if (m_elapsed500MSOutgoingPacketHandler >= 10)
+                    {
+                        m_sendPing = true;
+                        m_elapsed500MSOutgoingPacketHandler = 0;
+                    }
+                    #endregion Update Timers
+
+                    // Handle outgoing packets, resends, acknowledgements, and pings for each
+                    // client. m_packetSent will be set to true if a packet is sent
+                    Scene.ForEachClient(clientPacketHandler);
+
+                    m_currentOutgoingClient = null;
+
+                    // If nothing was sent, sleep for the minimum amount of time before a
+                    // token bucket could get more tokens
+
+                    if(Scene.GetNumberOfClients() == 0)
+                    {
+                        Thread.Sleep(100);
+                    }
+                    else if (!m_packetSent)
+//                        Thread.Sleep((int)TickCountResolution);  outch this is bad on linux
+                        Thread.Sleep(15); // match the 16ms of windows7, dont ask 16 or win may decide to do 32ms.
+
+                    Watchdog.UpdateThread();
+                }
+                catch (Exception ex)
+                {
+                    m_log.Error("[LLUDPSERVER]: OutgoingPacketHandler loop threw an exception: " + ex.Message, ex);
+                }
+            }
+
+            Watchdog.RemoveThread();
+        }
+
+        protected void ClientOutgoingPacketHandler(IClientAPI client)
+        {
+            m_currentOutgoingClient = client;
+
+            try
+            {
+                if (client is LLClientView)
+                {
+                    LLClientView llClient = (LLClientView)client;
+                    LLUDPClient udpClient = llClient.UDPClient;
+
+                    if (udpClient.IsConnected)
+                    {
+                        if (m_resendUnacked)
+                            HandleUnacked(llClient);
+
+                        if (m_sendAcks)
+                            SendAcks(udpClient);
+
+                        if (m_sendPing)
+                            SendPing(udpClient);
+
+                        // Dequeue any outgoing packets that are within the throttle limits
+                        if (udpClient.DequeueOutgoing())
+                            m_packetSent = true;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                m_log.Error(
+                    string.Format("[LLUDPSERVER]: OutgoingPacketHandler iteration for {0} threw ", client.Name), ex);
+            }
+        }
+
+        #region Emergency Monitoring
+        // Alternative packet handler fuull of instrumentation
+        // Handy for hunting bugs
+        protected Stopwatch watch1 = new Stopwatch();
+        protected Stopwatch watch2 = new Stopwatch();
+
+        protected float avgProcessingTicks = 0;
+        protected float avgResendUnackedTicks = 0;
+        protected float avgSendAcksTicks = 0;
+        protected float avgSendPingTicks = 0;
+        protected float avgDequeueTicks = 0;
+        protected long nticks = 0;
+        protected long nticksUnack = 0;
+        protected long nticksAck = 0;
+        protected long nticksPing = 0;
+        protected int npacksSent = 0;
+        protected int npackNotSent = 0;
+
+        /// <summary>
+        /// Number of inbound packets processed since startup.
+        /// </summary>
+        public long IncomingPacketsProcessed { get; protected set; }
+
+        #endregion
+
+        protected void ProcessInPacket(IncomingPacket incomingPacket)
+        {
+            Packet packet = incomingPacket.Packet;
+            LLClientView client = incomingPacket.Client;
+
+            if(!client.IsActive)
+                return;
+
+            m_currentIncomingClient = client;
+
+            try
+            {
+                // Process this packet
+                client.ProcessInPacket(packet);
+            }
+            catch(ThreadAbortException)
+            {
+                // If something is trying to abort the packet processing thread, take that as a hint that it's time to shut down
+                m_log.Info("[LLUDPSERVER]: Caught a thread abort, shutting down the LLUDP server");
+                Stop();
+            }
+            catch(Exception e)
+            {
+                // Don't let a failure in an individual client thread crash the whole sim.
+                m_log.Error(
+                    string.Format(
+                        "[LLUDPSERVER]: Client packet handler for {0} for packet {1} threw ",
+                        client.Name,packet.Type),
+                    e);
+            }
+            finally
+            {
+                m_currentIncomingClient = null;
+            }
+
+            IncomingPacketsProcessed++;
+        }
+
+        protected void LogoutHandler(IClientAPI client)
+        {
+            client.SendLogoutPacket();
+
+            if (!client.IsLoggingOut)
+            {
+                client.IsLoggingOut = true;
+                Scene.CloseAgent(client.AgentId, false);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServerCommands.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServerCommands.cs
new file mode 100644
index 0000000..012a57d
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServerCommands.cs
@@ -0,0 +1,880 @@
+/*
+ * 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;
+using NDesk.Options;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    public class LLUDPServerCommands
+    {
+        private ICommandConsole m_console;
+        private LLUDPServer m_udpServer;
+
+        public LLUDPServerCommands(ICommandConsole console, LLUDPServer udpServer)
+        {
+            m_console = console;
+            m_udpServer = udpServer;
+        }
+
+        public void Register()
+        {
+/*
+            m_console.Commands.AddCommand(
+                "Comms", false, "show server throttles",
+                "show server throttles",
+                "Show information about server throttles",
+                HandleShowServerThrottlesCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug", false, "debug lludp packet",
+                "debug lludp packet [--default | --all] <level> [<avatar-first-name> <avatar-last-name>]",
+                "Turn on packet debugging.  This logs information when the client stack hands a processed packet off to downstream code or when upstream code first requests that a certain packet be sent.",
+                "If level >  255 then all incoming and outgoing packets are logged.\n"
+                + "If level <= 255 then incoming AgentUpdate and outgoing SimStats and SimulatorViewerTimeMessage packets are not logged.\n"
+                + "If level <= 200 then incoming RequestImage and outgoing ImagePacket, ImageData, LayerData and CoarseLocationUpdate packets are not logged.\n"
+                + "If level <= 100 then incoming ViewerEffect and AgentAnimation and outgoing ViewerEffect and AvatarAnimation packets are not logged.\n"
+                + "If level <=  50 then outgoing ImprovedTerseObjectUpdate packets are not logged.\n"
+                + "If level <= 0 then no packets are logged.\n"
+                + "If --default is specified then the level becomes the default logging level for all subsequent agents.\n"
+                + "If --all is specified then the level becomes the default logging level for all current and subsequent agents.\n"
+                + "In these cases, you cannot also specify an avatar name.\n"
+                + "If an avatar name is given then only packets from that avatar are logged.",
+                HandlePacketCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug", false, "debug lludp data out",
+                "debug lludp data out <level> <avatar-first-name> <avatar-last-name>\"",
+                "Turn on debugging for final outgoing data to the given user's client.",
+                "This operates at a much lower level than the packet command and prints out available details when the data is actually sent.\n"
+                + "If level >  0 then information about all outgoing UDP data for this avatar is logged.\n"
+                + "If level <= 0 then no information about outgoing UDP data for this avatar is logged.",
+                HandleDataCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug", false, "debug lludp drop",
+                "debug lludp drop <in|out> <add|remove> <packet-name>",
+                "Drop all in or outbound packets that match the given name",
+                "For test purposes.",
+                HandleDropCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp start",
+                "debug lludp start <in|out|all>",
+                "Control LLUDP packet processing.",
+                "No effect if packet processing has already started.\n"
+                + "in  - start inbound processing.\n"
+                + "out - start outbound processing.\n"
+                + "all - start in and outbound processing.\n",
+                HandleStartCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp stop",
+                "debug lludp stop <in|out|all>",
+                "Stop LLUDP packet processing.",
+                "No effect if packet processing has already stopped.\n"
+                + "in  - stop inbound processing.\n"
+                + "out - stop outbound processing.\n"
+                + "all - stop in and outbound processing.\n",
+                HandleStopCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp pool",
+                "debug lludp pool <on|off>",
+                "Turn object pooling within the lludp component on or off.",
+                HandlePoolCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp status",
+                "debug lludp status",
+                "Return status of LLUDP packet processing.",
+                HandleStatusCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp throttles log",
+                "debug lludp throttles log <level> [<avatar-first-name> <avatar-last-name>]",
+                "Change debug logging level for throttles.",
+                "If level >= 0 then throttle debug logging is performed.\n"
+                + "If level <= 0 then no throttle debug logging is performed.",
+                HandleThrottleCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp throttles get",
+                "debug lludp throttles get [<avatar-first-name> <avatar-last-name>]",
+                "Return debug settings for throttles.",
+                      "adaptive - true/false, controls adaptive throttle setting.\n"
+                    + "request  - request drip rate in kbps.\n"
+                    + "max      - the max kbps throttle allowed for the specified existing clients.  Use 'debug lludp get new-client-throttle-max' to see the setting for new clients.\n",
+                HandleThrottleGetCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp throttles set",
+                "debug lludp throttles set <param> <value> [<avatar-first-name> <avatar-last-name>]",
+                "Set a throttle parameter for the given client.",
+                      "adaptive - true/false, controls adaptive throttle setting.\n"
+                    + "current  - current drip rate in kbps.\n"
+                    + "request  - requested drip rate in kbps.\n"
+                    + "max      - the max kbps throttle allowed for the specified existing clients.  Use 'debug lludp set new-client-throttle-max' to change the settings for new clients.\n",
+                HandleThrottleSetCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp get",
+                "debug lludp get",
+                "Get debug parameters for the server.",
+                      "max-scene-throttle      - the current max cumulative kbps provided for this scene to clients.\n"
+                    + "max-new-client-throttle - the max kbps throttle allowed to new clients.   Use 'debug lludp throttles get max' to see the settings for existing clients.",
+                HandleGetCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp set",
+                "debug lludp set <param> <value>",
+                "Set a parameter for the server.",
+                      "max-scene-throttle      - the current max cumulative kbps provided for this scene to clients.\n"
+                    + "max-new-client-throttle - the max kbps throttle allowed to each new client.  Use 'debug lludp throttles set max' to set for existing clients.",
+                HandleSetCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp toggle agentupdate",
+                "debug lludp toggle agentupdate",
+                "Toggle whether agentupdate packets are processed or simply discarded.",
+                HandleAgentUpdateCommand);
+
+            MainConsole.Instance.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp oqre",
+                "debug lludp oqre <start|stop|status>",
+                "Start, stop or get status of OutgoingQueueRefillEngine.",
+                "If stopped then refill requests are processed directly via the threadpool.",
+                HandleOqreCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp client get",
+                "debug lludp client get [<avatar-first-name> <avatar-last-name>]",
+                "Get debug parameters for the client.  If no name is given then all client information is returned.",
+                "process-unacked-sends - Do we take action if a sent reliable packet has not been acked.",
+                HandleClientGetCommand);
+
+            m_console.Commands.AddCommand(
+                "Debug",
+                false,
+                "debug lludp client set",
+                "debug lludp client set <param> <value> [<avatar-first-name> <avatar-last-name>]",
+                "Set a debug parameter for a particular client.  If no name is given then the value is set on all clients.",
+                "process-unacked-sends - Do we take action if a sent reliable packet has not been acked.",
+                HandleClientSetCommand);
+*/
+        }
+
+        private void HandleShowServerThrottlesCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            m_console.OutputFormat("Throttles for {0}", m_udpServer.Scene.Name);
+            ConsoleDisplayList cdl = new ConsoleDisplayList();
+            cdl.AddRow("Adaptive throttles", m_udpServer.ThrottleRates.AdaptiveThrottlesEnabled);
+
+            long maxSceneDripRate = (long)m_udpServer.Throttle.MaxDripRate;
+            cdl.AddRow(
+                "Max scene throttle",
+                maxSceneDripRate != 0 ? string.Format("{0} kbps", maxSceneDripRate * 8 / 1000) : "unset");
+
+            int maxClientDripRate = m_udpServer.ThrottleRates.Total;
+            cdl.AddRow(
+                "Max new client throttle",
+                maxClientDripRate != 0 ? string.Format("{0} kbps", maxClientDripRate * 8 / 1000) : "unset");
+
+            m_console.Output(cdl.ToString());
+
+            m_console.OutputFormat("{0}\n", GetServerThrottlesReport(m_udpServer));
+        }
+
+        private string GetServerThrottlesReport(LLUDPServer udpServer)
+        {
+            StringBuilder report = new StringBuilder();
+
+            report.AppendFormat(
+                "{0,7} {1,8} {2,7} {3,7} {4,7} {5,7} {6,9} {7,7}\n",
+                "Total",
+                "Resend",
+                "Land",
+                "Wind",
+                "Cloud",
+                "Task",
+                "Texture",
+                "Asset");
+
+            report.AppendFormat(
+                "{0,7} {1,8} {2,7} {3,7} {4,7} {5,7} {6,9} {7,7}\n",
+                "kb/s",
+                "kb/s",
+                "kb/s",
+                "kb/s",
+                "kb/s",
+                "kb/s",
+                "kb/s",
+                "kb/s");
+
+            ThrottleRates throttleRates = udpServer.ThrottleRates;
+            report.AppendFormat(
+                "{0,7} {1,8} {2,7} {3,7} {4,7} {5,7} {6,9} {7,7}",
+                (throttleRates.Total * 8) / 1000,
+                (throttleRates.Resend * 8) / 1000,
+                (throttleRates.Land * 8) / 1000,
+                (throttleRates.Wind * 8) / 1000,
+                (throttleRates.Cloud * 8) / 1000,
+                (throttleRates.Task * 8) / 1000,
+                (throttleRates.Texture  * 8) / 1000,
+                (throttleRates.Asset  * 8) / 1000);
+
+            return report.ToString();
+        }
+
+        protected string GetColumnEntry(string entry, int maxLength, int columnPadding)
+        {
+            return string.Format(
+                "{0,-" + maxLength +  "}{1,-" + columnPadding + "}",
+                entry.Length > maxLength ? entry.Substring(0, maxLength) : entry,
+                "");
+        }
+
+        private void HandleDataCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            if (args.Length != 7)
+            {
+                MainConsole.Instance.OutputFormat("Usage: debug lludp data out <true|false> <avatar-first-name> <avatar-last-name>");
+                return;
+            }
+
+            int level;
+            if (!ConsoleUtil.TryParseConsoleInt(MainConsole.Instance, args[4], out level))
+                return;
+
+            string firstName = args[5];
+            string lastName = args[6];
+
+            m_udpServer.Scene.ForEachScenePresence(sp =>
+                                       {
+                if (sp.Firstname == firstName && sp.Lastname == lastName)
+                {
+                    MainConsole.Instance.OutputFormat(
+                        "Data debug for {0} ({1}) set to {2} in {3}",
+                        sp.Name, sp.IsChildAgent ? "child" : "root", level, m_udpServer.Scene.Name);
+
+                    ((LLClientView)sp.ControllingClient).UDPClient.DebugDataOutLevel = level;
+                }
+            });
+        }
+
+        private void HandleThrottleCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            bool all = args.Length == 5;
+            bool one = args.Length == 7;
+
+            if (!all && !one)
+            {
+                MainConsole.Instance.OutputFormat(
+                    "Usage: debug lludp throttles log <level> [<avatar-first-name> <avatar-last-name>]");
+                return;
+            }
+
+            int level;
+            if (!ConsoleUtil.TryParseConsoleInt(MainConsole.Instance, args[4], out level))
+                return;
+
+            string firstName = null;
+            string lastName = null;
+
+            if (one)
+            {
+                firstName = args[5];
+                lastName = args[6];
+            }
+
+            m_udpServer.Scene.ForEachScenePresence(sp =>
+            {
+                if (all || (sp.Firstname == firstName && sp.Lastname == lastName))
+                {
+                    MainConsole.Instance.OutputFormat(
+                        "Throttle log level for {0} ({1}) set to {2} in {3}",
+                        sp.Name, sp.IsChildAgent ? "child" : "root", level, m_udpServer.Scene.Name);
+
+                    ((LLClientView)sp.ControllingClient).UDPClient.ThrottleDebugLevel = level;
+                }
+            });
+        }
+
+        private void HandleThrottleSetCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            bool all = args.Length == 6;
+            bool one = args.Length == 8;
+
+            if (!all && !one)
+            {
+                MainConsole.Instance.OutputFormat(
+                    "Usage: debug lludp throttles set <param> <value> [<avatar-first-name> <avatar-last-name>]");
+                return;
+            }
+
+            string param = args[4];
+            string rawValue = args[5];
+
+            string firstName = null;
+            string lastName = null;
+
+            if (one)
+            {
+                firstName = args[6];
+                lastName = args[7];
+            }
+
+            if (param == "adaptive")
+            {
+                bool newValue;
+                if (!ConsoleUtil.TryParseConsoleBool(MainConsole.Instance, rawValue, out newValue))
+                    return;
+
+                m_udpServer.Scene.ForEachScenePresence(sp =>
+                {
+                    if (all || (sp.Firstname == firstName && sp.Lastname == lastName))
+                    {
+                        MainConsole.Instance.OutputFormat(
+                            "Setting param {0} to {1} for {2} ({3}) in {4}",
+                            param, newValue, sp.Name, sp.IsChildAgent ? "child" : "root", m_udpServer.Scene.Name);
+
+                        LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+                        udpClient.FlowThrottle.AdaptiveEnabled = newValue;
+                        //                        udpClient.FlowThrottle.MaxDripRate = 0;
+                        //                        udpClient.FlowThrottle.AdjustedDripRate = 0;
+                    }
+                });
+            }
+            else if (param == "request")
+            {
+                int newValue;
+                if (!ConsoleUtil.TryParseConsoleInt(MainConsole.Instance, rawValue, out newValue))
+                    return;
+
+                int newCurrentThrottleKbps = newValue * 1000 / 8;
+
+                m_udpServer.Scene.ForEachScenePresence(sp =>
+                                                       {
+                    if (all || (sp.Firstname == firstName && sp.Lastname == lastName))
+                    {
+                        MainConsole.Instance.OutputFormat(
+                            "Setting param {0} to {1} for {2} ({3}) in {4}",
+                            param, newValue, sp.Name, sp.IsChildAgent ? "child" : "root", m_udpServer.Scene.Name);
+
+                        LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+                        udpClient.FlowThrottle.RequestedDripRate = newCurrentThrottleKbps;
+                    }
+                });
+            }
+            else if (param == "max")
+            {
+                int newValue;
+                if (!ConsoleUtil.TryParseConsoleInt(MainConsole.Instance, rawValue, out newValue))
+                    return;
+
+                int newThrottleMaxKbps = newValue * 1000 / 8;
+
+                m_udpServer.Scene.ForEachScenePresence(sp =>
+                {
+                    if (all || (sp.Firstname == firstName && sp.Lastname == lastName))
+                    {
+                        MainConsole.Instance.OutputFormat(
+                            "Setting param {0} to {1} for {2} ({3}) in {4}",
+                            param, newValue, sp.Name, sp.IsChildAgent ? "child" : "root", m_udpServer.Scene.Name);
+
+                        LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+                        udpClient.FlowThrottle.MaxDripRate = newThrottleMaxKbps;
+                    }
+                });
+            }
+        }
+
+        private void HandleThrottleGetCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            bool all = args.Length == 4;
+            bool one = args.Length == 6;
+
+            if (!all && !one)
+            {
+                MainConsole.Instance.OutputFormat(
+                    "Usage: debug lludp throttles get [<avatar-first-name> <avatar-last-name>]");
+                return;
+            }
+
+            string firstName = null;
+            string lastName = null;
+
+            if (one)
+            {
+                firstName = args[4];
+                lastName = args[5];
+            }
+
+            m_udpServer.Scene.ForEachScenePresence(sp =>
+             {
+                if (all || (sp.Firstname == firstName && sp.Lastname == lastName))
+                {
+                    m_console.OutputFormat(
+                        "Status for {0} ({1}) in {2}",
+                        sp.Name, sp.IsChildAgent ? "child" : "root", m_udpServer.Scene.Name);
+
+                    LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+
+                    ConsoleDisplayList cdl = new ConsoleDisplayList();
+                    cdl.AddRow("adaptive", udpClient.FlowThrottle.AdaptiveEnabled);
+                    cdl.AddRow("current", string.Format("{0} kbps", udpClient.FlowThrottle.DripRate * 8 / 1000));
+                    cdl.AddRow("request", string.Format("{0} kbps", udpClient.FlowThrottle.RequestedDripRate * 8 / 1000));
+                    cdl.AddRow("max", string.Format("{0} kbps", udpClient.FlowThrottle.MaxDripRate * 8 / 1000));
+
+                    m_console.Output(cdl.ToString());
+                }
+            });
+        }
+
+        private void HandleGetCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            m_console.OutputFormat("Debug settings for {0}", m_udpServer.Scene.Name);
+            ConsoleDisplayList cdl = new ConsoleDisplayList();
+
+            long maxSceneDripRate = (long)m_udpServer.Throttle.MaxDripRate;
+            cdl.AddRow(
+                "max-scene-throttle",
+                maxSceneDripRate != 0 ? string.Format("{0} kbps", maxSceneDripRate * 8 / 1000) : "unset");
+
+            int maxClientDripRate = m_udpServer.ThrottleRates.Total;
+            cdl.AddRow(
+                "max-new-client-throttle",
+                maxClientDripRate != 0 ? string.Format("{0} kbps", maxClientDripRate * 8 / 1000) : "unset");
+
+            m_console.Output(cdl.ToString());
+        }
+
+        private void HandleSetCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            if (args.Length != 5)
+            {
+                MainConsole.Instance.OutputFormat("Usage: debug lludp set <param> <value>");
+                return;
+            }
+
+            string param = args[3];
+            string rawValue = args[4];
+
+            int newValue;
+
+            if (param == "max-scene-throttle")
+            {
+                if (!ConsoleUtil.TryParseConsoleInt(MainConsole.Instance, rawValue, out newValue))
+                    return;
+
+                m_udpServer.Throttle.MaxDripRate = newValue * 1000 / 8;
+            }
+            else if (param == "max-new-client-throttle")
+            {
+                if (!ConsoleUtil.TryParseConsoleInt(MainConsole.Instance, rawValue, out newValue))
+                    return;
+
+                m_udpServer.ThrottleRates.Total = newValue * 1000 / 8;
+            }
+            else
+            {
+                return;
+            }
+
+            m_console.OutputFormat("{0} set to {1} in {2}", param, rawValue, m_udpServer.Scene.Name);
+        }
+
+/* not in use, nothing to set/get from lludp
+        private void HandleClientGetCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            if (args.Length != 4 && args.Length != 6)
+            {
+                MainConsole.Instance.OutputFormat("Usage: debug lludp client get [<avatar-first-name> <avatar-last-name>]");
+                return;
+            }
+
+            string name = null;
+
+            if (args.Length == 6)
+                name = string.Format("{0} {1}", args[4], args[5]);
+
+            m_udpServer.Scene.ForEachScenePresence(
+                sp =>
+                {
+                    if ((name == null || sp.Name == name) && sp.ControllingClient is LLClientView)
+                    {
+                        LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+
+                        m_console.OutputFormat(
+                            "Client debug parameters for {0} ({1}) in {2}",
+                            sp.Name, sp.IsChildAgent ? "child" : "root", m_udpServer.Scene.Name);
+                    }
+                });
+        }
+
+        private void HandleClientSetCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            if (args.Length != 6 && args.Length != 8)
+            {
+                MainConsole.Instance.OutputFormat("Usage: debug lludp client set <param> <value> [<avatar-first-name> <avatar-last-name>]");
+                return;
+            }
+
+            string param = args[4];
+            string rawValue = args[5];
+
+            string name = null;
+
+            if (args.Length == 8)
+                name = string.Format("{0} {1}", args[6], args[7]);
+            // nothing here now
+        }
+*/
+        private void HandlePacketCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            bool setAsDefaultLevel = false;
+            bool setAll = false;
+            OptionSet optionSet = new OptionSet()
+                .Add("default", o => setAsDefaultLevel = (o != null))
+                    .Add("all", o => setAll = (o != null));
+            List<string> filteredArgs = optionSet.Parse(args);
+
+            string name = null;
+
+            if (filteredArgs.Count == 6)
+            {
+                if (!(setAsDefaultLevel || setAll))
+                {
+                    name = string.Format("{0} {1}", filteredArgs[4], filteredArgs[5]);
+                }
+                else
+                {
+                    MainConsole.Instance.OutputFormat("ERROR: Cannot specify a user name when setting default/all logging level");
+                    return;
+                }
+            }
+
+            if (filteredArgs.Count > 3)
+            {
+                int newDebug;
+                if (int.TryParse(filteredArgs[3], out newDebug))
+                {
+                    if (setAsDefaultLevel || setAll)
+                    {
+                        m_udpServer.DefaultClientPacketDebugLevel = newDebug;
+
+                        MainConsole.Instance.OutputFormat(
+                            "Packet debug for {0} clients set to {1} in {2}",
+                            (setAll ? "all" : "future"), m_udpServer.DefaultClientPacketDebugLevel, m_udpServer.Scene.Name);
+
+                        if (setAll)
+                        {
+                            m_udpServer.Scene.ForEachScenePresence(sp =>
+                                                       {
+                                MainConsole.Instance.OutputFormat(
+                                    "Packet debug for {0} ({1}) set to {2} in {3}",
+                                    sp.Name, sp.IsChildAgent ? "child" : "root", newDebug, m_udpServer.Scene.Name);
+
+                                sp.ControllingClient.DebugPacketLevel = newDebug;
+                            });
+                        }
+                    }
+                    else
+                    {
+                        m_udpServer.Scene.ForEachScenePresence(sp =>
+                                                   {
+                            if (name == null || sp.Name == name)
+                            {
+                                MainConsole.Instance.OutputFormat(
+                                    "Packet debug for {0} ({1}) set to {2} in {3}",
+                                    sp.Name, sp.IsChildAgent ? "child" : "root", newDebug, m_udpServer.Scene.Name);
+
+                                sp.ControllingClient.DebugPacketLevel = newDebug;
+                            }
+                        });
+                    }
+                }
+                else
+                {
+                    MainConsole.Instance.Output("Usage: debug lludp packet [--default | --all] 0..255 [<first-name> <last-name>]");
+                }
+            }
+        }
+
+        private void HandleDropCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            if (args.Length != 6)
+            {
+                MainConsole.Instance.Output("Usage: debug lludp drop <in|out> <add|remove> <packet-name>");
+                return;
+            }
+
+            string direction = args[3];
+            string subCommand = args[4];
+            string packetName = args[5];
+
+            if (subCommand == "add")
+            {
+                MainConsole.Instance.OutputFormat(
+                    "Adding packet {0} to {1} drop list for all connections in {2}",
+                    direction, packetName, m_udpServer.Scene.Name);
+
+                m_udpServer.Scene.ForEachScenePresence(
+                    sp =>
+                    {
+                    LLClientView llcv = (LLClientView)sp.ControllingClient;
+
+                    if (direction == "in")
+                        llcv.AddInPacketToDropSet(packetName);
+                    else if (direction == "out")
+                        llcv.AddOutPacketToDropSet(packetName);
+                }
+                );
+            }
+            else if (subCommand == "remove")
+            {
+                MainConsole.Instance.OutputFormat(
+                    "Removing packet {0} from {1} drop list for all connections in {2}",
+                    direction, packetName, m_udpServer.Scene.Name);
+
+                m_udpServer.Scene.ForEachScenePresence(
+                    sp =>
+                    {
+                    LLClientView llcv = (LLClientView)sp.ControllingClient;
+
+                    if (direction == "in")
+                        llcv.RemoveInPacketFromDropSet(packetName);
+                    else if (direction == "out")
+                        llcv.RemoveOutPacketFromDropSet(packetName);
+                }
+                );
+            }
+        }
+
+        private void HandleStartCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            if (args.Length != 4)
+            {
+                MainConsole.Instance.Output("Usage: debug lludp start <in|out|all>");
+                return;
+            }
+
+            string subCommand = args[3];
+
+            if (subCommand == "in" || subCommand == "all")
+                m_udpServer.StartInbound();
+
+            if (subCommand == "out" || subCommand == "all")
+                m_udpServer.StartOutbound();
+        }
+
+        private void HandleStopCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            if (args.Length != 4)
+            {
+                MainConsole.Instance.Output("Usage: debug lludp stop <in|out|all>");
+                return;
+            }
+
+            string subCommand = args[3];
+
+            if (subCommand == "in" || subCommand == "all")
+                m_udpServer.StopInbound();
+
+            if (subCommand == "out" || subCommand == "all")
+                m_udpServer.StopOutbound();
+        }
+
+        private void HandlePoolCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            if (args.Length != 4)
+            {
+                MainConsole.Instance.Output("Usage: debug lludp pool <on|off>");
+                return;
+            }
+
+            string enabled = args[3];
+
+            if (enabled == "on")
+            {
+                if (m_udpServer.EnablePools())
+                {
+                    m_udpServer.EnablePoolStats();
+                    MainConsole.Instance.OutputFormat("Packet pools enabled on {0}", m_udpServer.Scene.Name);
+                }
+            }
+            else if (enabled == "off")
+            {
+                if (m_udpServer.DisablePools())
+                {
+                    m_udpServer.DisablePoolStats();
+                    MainConsole.Instance.OutputFormat("Packet pools disabled on {0}", m_udpServer.Scene.Name);
+                }
+            }
+            else
+            {
+                MainConsole.Instance.Output("Usage: debug lludp pool <on|off>");
+            }
+        }
+
+        private void HandleAgentUpdateCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            m_udpServer.DiscardInboundAgentUpdates = !m_udpServer.DiscardInboundAgentUpdates;
+
+            MainConsole.Instance.OutputFormat(
+                "Discard AgentUpdates now {0} for {1}", m_udpServer.DiscardInboundAgentUpdates, m_udpServer.Scene.Name);
+        }
+
+        private void HandleStatusCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            MainConsole.Instance.OutputFormat(
+                "IN  LLUDP packet processing for {0} is {1}", m_udpServer.Scene.Name, m_udpServer.IsRunningInbound ? "enabled" : "disabled");
+
+            MainConsole.Instance.OutputFormat(
+                "OUT LLUDP packet processing for {0} is {1}", m_udpServer.Scene.Name, m_udpServer.IsRunningOutbound ? "enabled" : "disabled");
+
+            MainConsole.Instance.OutputFormat("LLUDP pools in {0} are {1}", m_udpServer.Scene.Name, m_udpServer.UsePools ? "on" : "off");
+
+            MainConsole.Instance.OutputFormat(
+                "Packet debug level for new clients is {0}", m_udpServer.DefaultClientPacketDebugLevel);
+        }
+
+        private void HandleOqreCommand(string module, string[] args)
+        {
+            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
+                return;
+
+            if (args.Length != 4)
+            {
+                MainConsole.Instance.Output("Usage: debug lludp oqre <stop|start|status>");
+                return;
+            }
+
+            string subCommand = args[3];
+
+            if (subCommand == "stop")
+            {
+                m_udpServer.OqrEngine.Stop();
+                MainConsole.Instance.OutputFormat("Stopped OQRE for {0}", m_udpServer.Scene.Name);
+            }
+            else if (subCommand == "start")
+            {
+                m_udpServer.OqrEngine.Start();
+                MainConsole.Instance.OutputFormat("Started OQRE for {0}", m_udpServer.Scene.Name);
+            }
+            else if (subCommand == "status")
+            {
+                MainConsole.Instance.OutputFormat("OQRE in {0}", m_udpServer.Scene.Name);
+                MainConsole.Instance.OutputFormat("Running: {0}", m_udpServer.OqrEngine.IsRunning);
+                MainConsole.Instance.OutputFormat(
+                    "Requests waiting: {0}",
+                    m_udpServer.OqrEngine.IsRunning ? m_udpServer.OqrEngine.JobsWaiting.ToString() : "n/a");
+            }
+            else
+            {
+                MainConsole.Instance.OutputFormat("Unrecognized OQRE subcommand {0}", subCommand);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
new file mode 100644
index 0000000..f362b06
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
@@ -0,0 +1,535 @@
+/*
+ * Copyright (c) 2006, Clutch, Inc.
+ * Original Author: Jeff Cesnik
+ * All rights reserved.
+ *
+ * - 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.
+ * - Neither the name of the openmetaverse.org 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR 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.Net;
+using System.Net.Sockets;
+using System.Threading;
+using log4net;
+using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenMetaverse
+{
+    /// <summary>
+    /// Base UDP server
+    /// </summary>
+    public abstract class OpenSimUDPBase
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// This method is called when an incoming packet is received
+        /// </summary>
+        /// <param name="buffer">Incoming packet buffer</param>
+        public abstract void PacketReceived(UDPPacketBuffer buffer);
+
+        /// <summary>UDP port to bind to in server mode</summary>
+        protected int m_udpPort;
+
+        /// <summary>Local IP address to bind to in server mode</summary>
+        protected IPAddress m_localBindAddress;
+
+        /// <summary>UDP socket, used in either client or server mode</summary>
+        private Socket m_udpSocket;
+
+        /// <summary>
+        /// Are we to use object pool(s) to reduce memory churn when receiving data?
+        /// </summary>
+        public bool UsePools { get; protected set; }
+
+        /// <summary>
+        /// Pool to use for handling data.  May be null if UsePools = false;
+        /// </summary>
+        protected OpenSim.Framework.Pool<UDPPacketBuffer> Pool { get; private set; }
+
+        /// <summary>Returns true if the server is currently listening for inbound packets, otherwise false</summary>
+        public bool IsRunningInbound { get; private set; }
+
+        /// <summary>Returns true if the server is currently sending outbound packets, otherwise false</summary>
+        /// <remarks>If IsRunningOut = false, then any request to send a packet is simply dropped.</remarks>
+        public bool IsRunningOutbound { get; private set; }
+
+        /// <summary>
+        /// Number of UDP receives.
+        /// </summary>
+        public int UdpReceives { get; private set; }
+
+        /// <summary>
+        /// Number of UDP sends
+        /// </summary>
+        public int UdpSends { get; private set; }
+
+        /// <summary>
+        /// Number of receives over which to establish a receive time average.
+        /// </summary>
+        private readonly static int s_receiveTimeSamples = 500;
+
+        /// <summary>
+        /// Current number of samples taken to establish a receive time average.
+        /// </summary>
+        private int m_currentReceiveTimeSamples;
+
+        /// <summary>
+        /// Cumulative receive time for the sample so far.
+        /// </summary>
+        private int m_receiveTicksInCurrentSamplePeriod;
+
+        /// <summary>
+        /// The average time taken for each require receive in the last sample.
+        /// </summary>
+        public float AverageReceiveTicksForLastSamplePeriod { get; private set; }
+
+        public int Port
+        {
+            get { return m_udpPort; }
+        }
+
+        #region PacketDropDebugging
+        /// <summary>
+        /// For debugging purposes only... random number generator for dropping
+        /// outbound packets.
+        /// </summary>
+        private Random m_dropRandomGenerator = new Random();
+
+        /// <summary>
+        /// For debugging purposes only... parameters for a simplified
+        /// model of packet loss with bursts, overall drop rate should
+        /// be roughly 1 - m_dropLengthProbability / (m_dropProbabiliy + m_dropLengthProbability)
+        /// which is about 1% for parameters 0.0015 and 0.15
+        /// </summary>
+        private double m_dropProbability = 0.0030;
+        private double m_dropLengthProbability = 0.15;
+        private bool m_dropState = false;
+
+        /// <summary>
+        /// For debugging purposes only... parameters to control the time
+        /// duration over which packet loss bursts can occur, if no packets
+        /// have been sent for m_dropResetTicks milliseconds, then reset the
+        /// state of the packet dropper to its default.
+        /// </summary>
+        private int m_dropLastTick = 0;
+        private int m_dropResetTicks = 500;
+
+        /// <summary>
+        /// Debugging code used to simulate dropped packets with bursts
+        /// </summary>
+        private bool DropOutgoingPacket()
+        {
+            double rnum = m_dropRandomGenerator.NextDouble();
+
+            // if the connection has been idle for awhile (more than m_dropResetTicks) then
+            // reset the state to the default state, don't continue a burst
+            int curtick = Util.EnvironmentTickCount();
+            if (Util.EnvironmentTickCountSubtract(curtick, m_dropLastTick) > m_dropResetTicks)
+                m_dropState = false;
+
+            m_dropLastTick = curtick;
+
+            // if we are dropping packets, then the probability of dropping
+            // this packet is the probability that we stay in the burst
+            if (m_dropState)
+            {
+                m_dropState = (rnum < (1.0 - m_dropLengthProbability)) ? true : false;
+            }
+            else
+            {
+                m_dropState = (rnum < m_dropProbability) ? true : false;
+            }
+
+            return m_dropState;
+        }
+        #endregion PacketDropDebugging
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="bindAddress">Local IP address to bind the server to</param>
+        /// <param name="port">Port to listening for incoming UDP packets on</param>
+        /// /// <param name="usePool">Are we to use an object pool to get objects for handing inbound data?</param>
+        public OpenSimUDPBase(IPAddress bindAddress, int port)
+        {
+            m_localBindAddress = bindAddress;
+            m_udpPort = port;
+
+            // for debugging purposes only, initializes the random number generator
+            // used for simulating packet loss
+            // m_dropRandomGenerator = new Random();
+        }
+
+        ~OpenSimUDPBase()
+        {
+            if(m_udpSocket !=null)
+                try { m_udpSocket.Close(); } catch { }
+        }
+        /// <summary>
+        /// Start inbound UDP packet handling.
+        /// </summary>
+        /// <param name="recvBufferSize">The size of the receive buffer for
+        /// the UDP socket. This value is passed up to the operating system
+        /// and used in the system networking stack. Use zero to leave this
+        /// value as the default</param>
+        /// <param name="asyncPacketHandling">Set this to true to start
+        /// receiving more packets while current packet handler callbacks are
+        /// still running. Setting this to false will complete each packet
+        /// callback before the next packet is processed</param>
+        /// <remarks>This method will attempt to set the SIO_UDP_CONNRESET flag
+        /// on the socket to get newer versions of Windows to behave in a sane
+        /// manner (not throwing an exception when the remote side resets the
+        /// connection). This call is ignored on Mono where the flag is not
+        /// necessary</remarks>
+        public virtual void StartInbound(int recvBufferSize)
+        {
+            if (!IsRunningInbound)
+            {
+                m_log.DebugFormat("[UDPBASE]: Starting inbound UDP loop");
+
+                const int SIO_UDP_CONNRESET = -1744830452;
+
+                IPEndPoint ipep = new IPEndPoint(m_localBindAddress, m_udpPort);
+
+                m_udpSocket = new Socket(
+                    AddressFamily.InterNetwork,
+                    SocketType.Dgram,
+                    ProtocolType.Udp);
+
+                try
+                {
+                    if (m_udpSocket.Ttl < 128)
+                    {
+                        m_udpSocket.Ttl = 128;
+                    }
+                }
+                catch (SocketException)
+                {
+                    m_log.Debug("[UDPBASE]: Failed to increase default TTL");
+                }
+
+                try
+                {
+                    // This udp socket flag is not supported under mono,
+                    // so we'll catch the exception and continue
+                    // Try does not protect some mono versions on mac
+                    if(Util.IsWindows())
+                    {
+                        m_udpSocket.IOControl(SIO_UDP_CONNRESET, new byte[] { 0 }, null);
+                        m_log.Debug("[UDPBASE]: SIO_UDP_CONNRESET flag set");
+                    }               
+                    else
+                    {
+                        m_log.Debug("[UDPBASE]: SIO_UDP_CONNRESET flag not supported on this platform, ignoring");
+                    }
+                }
+                catch
+                {
+                    m_log.Debug("[UDPBASE]: SIO_UDP_CONNRESET flag not supported on this platform, ignoring");
+                }
+
+                // On at least Mono 3.2.8, multiple UDP sockets can bind to the same port by default.  At the moment
+                // we never want two regions to listen on the same port as they cannot demultiplex each other's messages,
+                // leading to a confusing bug.
+                // By default, Windows does not allow two sockets to bind to the same port.
+                //
+                // Unfortunately, this also causes a crashed sim to leave the socket in a state
+                // where it appears to be in use but is really just hung from the old process
+                // crashing rather than closing it. While this protects agains misconfiguration,
+                // allowing crashed sims to be started up again right away, rather than having to
+                // wait 2 minutes for the socket to clear is more valuable. Commented 12/13/2016
+                // m_udpSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, false);
+
+                if (recvBufferSize != 0)
+                    m_udpSocket.ReceiveBufferSize = recvBufferSize;
+
+                m_udpSocket.Bind(ipep);
+
+                if (m_udpPort == 0)
+                    m_udpPort = ((IPEndPoint)m_udpSocket.LocalEndPoint).Port;
+
+                IsRunningInbound = true;
+
+                // kick off an async receive.  The Start() method will return, the
+                // actual receives will occur asynchronously and will be caught in
+                // AsyncEndRecieve().
+                AsyncBeginReceive();
+            }
+        }
+
+        /// <summary>
+        /// Start outbound UDP packet handling.
+        /// </summary>
+        public virtual void StartOutbound()
+        {
+            m_log.DebugFormat("[UDPBASE]: Starting outbound UDP loop");
+
+            IsRunningOutbound = true;
+        }
+
+        public virtual void StopInbound()
+        {
+            if (IsRunningInbound)
+            {
+                m_log.DebugFormat("[UDPBASE]: Stopping inbound UDP loop");
+
+                IsRunningInbound = false;
+                m_udpSocket.Close();
+            }
+        }
+
+        public virtual void StopOutbound()
+        {
+            m_log.DebugFormat("[UDPBASE]: Stopping outbound UDP loop");
+
+            IsRunningOutbound = false;
+        }
+
+        public virtual bool EnablePools()
+        {
+            if (!UsePools)
+            {
+                Pool = new Pool<UDPPacketBuffer>(() => new UDPPacketBuffer(), 500);
+
+                UsePools = true;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public virtual bool DisablePools()
+        {
+            if (UsePools)
+            {
+                UsePools = false;
+
+                // We won't null out the pool to avoid a race condition with code that may be in the middle of using it.
+
+                return true;
+            }
+
+            return false;
+        }
+
+        private void AsyncBeginReceive()
+        {
+            UDPPacketBuffer buf;
+
+            // FIXME: Disabled for now as this causes issues with reused packet objects interfering with each other
+            // on Windows with m_asyncPacketHandling = true, though this has not been seen on Linux.
+            // Possibly some unexpected issue with fetching UDP data concurrently with multiple threads.  Requires more investigation.
+//            if (UsePools)
+//                buf = Pool.GetObject();
+//            else
+                buf = new UDPPacketBuffer();
+
+            if (IsRunningInbound)
+            {
+                try
+                {
+                    // kick off an async read
+                    m_udpSocket.BeginReceiveFrom(
+                        //wrappedBuffer.Instance.Data,
+                        buf.Data,
+                        0,
+                        UDPPacketBuffer.BUFFER_SIZE,
+                        SocketFlags.None,
+                        ref buf.RemoteEndPoint,
+                        AsyncEndReceive,
+                        //wrappedBuffer);
+                        buf);
+                }
+                catch (SocketException e)
+                {
+                    if (e.SocketErrorCode == SocketError.ConnectionReset)
+                    {
+                        m_log.Warn("[UDPBASE]: SIO_UDP_CONNRESET was ignored, attempting to salvage the UDP listener on port " + m_udpPort);
+                        bool salvaged = false;
+                        while (!salvaged)
+                        {
+                            try
+                            {
+                                m_udpSocket.BeginReceiveFrom(
+                                    //wrappedBuffer.Instance.Data,
+                                    buf.Data,
+                                    0,
+                                    UDPPacketBuffer.BUFFER_SIZE,
+                                    SocketFlags.None,
+                                    ref buf.RemoteEndPoint,
+                                    AsyncEndReceive,
+                                    //wrappedBuffer);
+                                    buf);
+                                salvaged = true;
+                            }
+                            catch (SocketException) { }
+                            catch (ObjectDisposedException) { return; }
+                        }
+
+                        m_log.Warn("[UDPBASE]: Salvaged the UDP listener on port " + m_udpPort);
+                    }
+                }
+                catch (ObjectDisposedException e)
+                {
+                    m_log.Error(
+                        string.Format("[UDPBASE]: Error processing UDP begin receive {0}.  Exception  ", UdpReceives), e);
+                }
+                catch (Exception e)
+                {
+                    m_log.Error(
+                        string.Format("[UDPBASE]: Error processing UDP begin receive {0}.  Exception  ", UdpReceives), e);
+                }
+            }
+        }
+
+        private void AsyncEndReceive(IAsyncResult iar)
+        {
+            // Asynchronous receive operations will complete here through the call
+            // to AsyncBeginReceive
+            if (IsRunningInbound)
+            {
+                UdpReceives++;
+ 
+                try
+                {
+                    // get the buffer that was created in AsyncBeginReceive
+                    // this is the received data
+                    UDPPacketBuffer buffer = (UDPPacketBuffer)iar.AsyncState;
+
+                    int startTick = Util.EnvironmentTickCount();
+
+                    // get the length of data actually read from the socket, store it with the
+                    // buffer
+                    buffer.DataLength = m_udpSocket.EndReceiveFrom(iar, ref buffer.RemoteEndPoint);
+
+                    // call the abstract method PacketReceived(), passing the buffer that
+                    // has just been filled from the socket read.
+                    PacketReceived(buffer);
+
+                    // If more than one thread can be calling AsyncEndReceive() at once (e.g. if m_asyncPacketHandler)
+                    // then a particular stat may be inaccurate due to a race condition.  We won't worry about this
+                    // since this should be rare and  won't cause a runtime problem.
+                    if (m_currentReceiveTimeSamples >= s_receiveTimeSamples)
+                    {
+                        AverageReceiveTicksForLastSamplePeriod
+                            = (float)m_receiveTicksInCurrentSamplePeriod / s_receiveTimeSamples;
+
+                        m_receiveTicksInCurrentSamplePeriod = 0;
+                        m_currentReceiveTimeSamples = 0;
+                    }
+                    else
+                    {
+                        m_receiveTicksInCurrentSamplePeriod += Util.EnvironmentTickCountSubtract(startTick);
+                        m_currentReceiveTimeSamples++;
+                    }
+                }
+                catch (SocketException se)
+                {
+                    m_log.Error(
+                        string.Format(
+                            "[UDPBASE]: Error processing UDP end receive {0}, socket error code {1}.  Exception  ",
+                            UdpReceives, se.ErrorCode),
+                        se);
+                }
+                catch (ObjectDisposedException e)
+                {
+                    m_log.Error(
+                        string.Format("[UDPBASE]: Error processing UDP end receive {0}.  Exception  ", UdpReceives), e);
+                }
+                catch (Exception e)
+                {
+                    m_log.Error(
+                        string.Format("[UDPBASE]: Error processing UDP end receive {0}.  Exception  ", UdpReceives), e);
+                }
+                finally
+                {
+//                    if (UsePools)
+//                        Pool.ReturnObject(buffer);
+
+                    AsyncBeginReceive();
+                }
+            }
+        }
+
+        public void AsyncBeginSend(UDPPacketBuffer buf)
+        {
+//            if (IsRunningOutbound)
+//            {
+
+                // This is strictly for debugging purposes to simulate dropped
+                // packets when testing throttles & retransmission code
+                // if (DropOutgoingPacket())
+                //     return;
+
+                try
+                {
+                    m_udpSocket.BeginSendTo(
+                        buf.Data,
+                        0,
+                        buf.DataLength,
+                        SocketFlags.None,
+                        buf.RemoteEndPoint,
+                        AsyncEndSend,
+                        buf);
+                }
+                catch (SocketException) { }
+                catch (ObjectDisposedException) { }
+ //           }
+        }
+
+        void AsyncEndSend(IAsyncResult result)
+        {
+            try
+            {
+//                UDPPacketBuffer buf = (UDPPacketBuffer)result.AsyncState;
+                m_udpSocket.EndSendTo(result);
+
+                UdpSends++;
+            }
+            catch (SocketException) { }
+            catch (ObjectDisposedException) { }
+        }
+
+        public void SyncSend(UDPPacketBuffer buf)
+        {
+            try
+            {
+                m_udpSocket.SendTo(
+                    buf.Data,
+                    0,
+                    buf.DataLength,
+                    SocketFlags.None,
+                    buf.RemoteEndPoint
+                    );
+                 UdpSends++;
+            }
+            catch (SocketException e)
+            {
+                m_log.Warn("[UDPBASE]: sync send SocketException {0} " + e.Message);
+            }
+            catch (ObjectDisposedException) { }
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/OutgoingPacket.cs b/OpenSim/Region/ClientStack/Linden/UDP/OutgoingPacket.cs
new file mode 100644
index 0000000..76c6c14
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/OutgoingPacket.cs
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using OpenSim.Framework;
+using OpenMetaverse;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+
+    public delegate void UnackedPacketMethod(OutgoingPacket oPacket);
+    /// <summary>
+    /// Holds a reference to the <seealso cref="LLUDPClient"/> this packet is
+    /// destined for, along with the serialized packet data, sequence number
+    /// (if this is a resend), number of times this packet has been resent,
+    /// the time of the last resend, and the throttling category for this
+    /// packet
+    /// </summary>
+    public sealed class OutgoingPacket
+    {
+        /// <summary>Client this packet is destined for</summary>
+        public LLUDPClient Client;
+        /// <summary>Packet data to send</summary>
+        public UDPPacketBuffer Buffer;
+        /// <summary>Sequence number of the wrapped packet</summary>
+        public uint SequenceNumber;
+        /// <summary>Number of times this packet has been resent</summary>
+        public int ResendCount;
+        /// <summary>Environment.TickCount when this packet was last sent over the wire</summary>
+        public int TickCount;
+        /// <summary>Category this packet belongs to</summary>
+        public ThrottleOutPacketType Category;
+        /// <summary>The delegate to be called if this packet is determined to be unacknowledged</summary>
+        public UnackedPacketMethod UnackedMethod;
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="client">Reference to the client this packet is destined for</param>
+        /// <param name="buffer">Serialized packet data. If the flags or sequence number
+        /// need to be updated, they will be injected directly into this binary buffer</param>
+        /// <param name="category">Throttling category for this packet</param>
+        public OutgoingPacket(LLUDPClient client, UDPPacketBuffer buffer, ThrottleOutPacketType category, UnackedPacketMethod method)
+        {
+            Client = client;
+            Buffer = buffer;
+            Category = category;
+            UnackedMethod = method;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
new file mode 100644
index 0000000..f585bea
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
@@ -0,0 +1,299 @@
+/*
+ * 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 OpenMetaverse;
+using OpenMetaverse.Packets;
+using log4net;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    public sealed class PacketPool
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static readonly PacketPool instance = new PacketPool();
+
+        /// <summary>
+        /// Pool of packets available for reuse.
+        /// </summary>
+        private readonly Dictionary<PacketType, Stack<Packet>> pool = new Dictionary<PacketType, Stack<Packet>>();
+
+        private static Dictionary<Type, Stack<Object>> DataBlocks = new Dictionary<Type, Stack<Object>>();
+
+        public static PacketPool Instance
+        {
+            get { return instance; }
+        }
+
+        public bool RecyclePackets { get; set; }
+
+        public bool RecycleDataBlocks { get; set; }
+
+        /// <summary>
+        /// The number of packets pooled
+        /// </summary>
+        public int PacketsPooled
+        {
+            get
+            {
+                lock (pool)
+                    return pool.Count;
+            }
+        }
+
+        /// <summary>
+        /// The number of blocks pooled.
+        /// </summary>
+        public int BlocksPooled
+        {
+            get
+            {
+                lock (DataBlocks)
+                    return DataBlocks.Count;
+            }
+        }
+
+        /// <summary>
+        /// Number of packets requested.
+        /// </summary>
+        public long PacketsRequested { get; private set; }
+
+        /// <summary>
+        /// Number of packets reused.
+        /// </summary>
+        public long PacketsReused { get; private set; }
+
+        /// <summary>
+        /// Number of packet blocks requested.
+        /// </summary>
+        public long BlocksRequested { get; private set; }
+
+        /// <summary>
+        /// Number of packet blocks reused.
+        /// </summary>
+        public long BlocksReused { get; private set; }
+
+        private PacketPool()
+        {
+            // defaults
+            RecyclePackets = true;
+            RecycleDataBlocks = true;
+        }
+
+        /// <summary>
+        /// Gets a packet of the given type.
+        /// </summary>
+        /// <param name='type'></param>
+        /// <returns>Guaranteed to always return a packet, whether from the pool or newly constructed.</returns>
+        public Packet GetPacket(PacketType type)
+        {
+            PacketsRequested++;
+
+            Packet packet;
+
+            if (!RecyclePackets)
+                return Packet.BuildPacket(type);
+
+            lock (pool)
+            {
+                if (!pool.ContainsKey(type) || pool[type] == null || (pool[type]).Count == 0)
+                {
+//                    m_log.DebugFormat("[PACKETPOOL]: Building {0} packet", type);
+
+                    // Creating a new packet if we cannot reuse an old package
+                    packet = Packet.BuildPacket(type);
+                }
+                else
+                {
+//                    m_log.DebugFormat("[PACKETPOOL]: Pulling {0} packet", type);
+
+                    // Recycle old packages
+                    PacketsReused++;
+
+                    packet = pool[type].Pop();
+                }
+            }
+
+            return packet;
+        }
+
+        private static PacketType GetType(byte[] bytes)
+        {
+            ushort id;
+            PacketFrequency freq;
+            bool isZeroCoded = (bytes[0] & Helpers.MSG_ZEROCODED) != 0;
+
+            if (bytes[6] == 0xFF)
+            {
+                if (bytes[7] == 0xFF)
+                {
+                    freq = PacketFrequency.Low;
+                    if (isZeroCoded && bytes[8] == 0)
+                        id = bytes[10];
+                    else
+                        id = (ushort)((bytes[8] << 8) + bytes[9]);
+                }
+                else
+                {
+                    freq = PacketFrequency.Medium;
+                    id = bytes[7];
+                }
+            }
+            else
+            {
+                freq = PacketFrequency.High;
+                id = bytes[6];
+            }
+
+            return Packet.GetType(id, freq);
+        }
+
+        public Packet GetPacket(byte[] bytes, ref int packetEnd, byte[] zeroBuffer)
+        {
+            PacketType type = GetType(bytes);
+
+//            Array.Clear(zeroBuffer, 0, zeroBuffer.Length);
+
+            int i = 0;
+            Packet packet = GetPacket(type);
+            if (packet == null)
+                m_log.WarnFormat("[PACKETPOOL]: Failed to get packet of type {0}", type);
+            else
+                packet.FromBytes(bytes, ref i, ref packetEnd, zeroBuffer);
+
+            return packet;
+        }
+
+        /// <summary>
+        /// Return a packet to the packet pool
+        /// </summary>
+        /// <param name="packet"></param>
+        public void ReturnPacket(Packet packet)
+        {
+            if (RecycleDataBlocks)
+            {
+                switch (packet.Type)
+                {
+                    case PacketType.ObjectUpdate:
+                        ObjectUpdatePacket oup = (ObjectUpdatePacket)packet;
+
+                        foreach (ObjectUpdatePacket.ObjectDataBlock oupod in oup.ObjectData)
+                            ReturnDataBlock<ObjectUpdatePacket.ObjectDataBlock>(oupod);
+
+                        oup.ObjectData = null;
+                        break;
+
+                    case PacketType.ImprovedTerseObjectUpdate:
+                        ImprovedTerseObjectUpdatePacket itoup = (ImprovedTerseObjectUpdatePacket)packet;
+
+                        foreach (ImprovedTerseObjectUpdatePacket.ObjectDataBlock itoupod in itoup.ObjectData)
+                            ReturnDataBlock<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>(itoupod);
+
+                        itoup.ObjectData = null;
+                        break;
+                }
+            }
+
+            if (RecyclePackets)
+            {
+                switch (packet.Type)
+                {
+                    // List pooling packets here
+                    case PacketType.AgentUpdate:
+                    case PacketType.PacketAck:
+                    case PacketType.ObjectUpdate:
+                    case PacketType.ImprovedTerseObjectUpdate:
+                        lock (pool)
+                        {
+                            PacketType type = packet.Type;
+
+                            if (!pool.ContainsKey(type))
+                            {
+                                pool[type] = new Stack<Packet>();
+                            }
+
+                            if ((pool[type]).Count < 50)
+                            {
+//                                m_log.DebugFormat("[PACKETPOOL]: Pushing {0} packet", type);
+
+                                pool[type].Push(packet);
+                            }
+                        }
+                        break;
+
+                    // Other packets wont pool
+                    default:
+                        return;
+                }
+            }
+        }
+
+        public T GetDataBlock<T>() where T: new()
+        {
+            lock (DataBlocks)
+            {
+                BlocksRequested++;
+
+                Stack<Object> s;
+
+                if (DataBlocks.TryGetValue(typeof(T), out s))
+                {
+                    if (s.Count > 0)
+                    {
+                        BlocksReused++;
+                        return (T)s.Pop();
+                    }
+                }
+                else
+                {
+                    DataBlocks[typeof(T)] = new Stack<Object>();
+                }
+
+                return new T();
+            }
+        }
+
+        public void ReturnDataBlock<T>(T block) where T: new()
+        {
+            if (block == null)
+                return;
+
+            lock (DataBlocks)
+            {
+                if (!DataBlocks.ContainsKey(typeof(T)))
+                    DataBlocks[typeof(T)] = new Stack<Object>();
+
+                if (DataBlocks[typeof(T)].Count < 50)
+                    DataBlocks[typeof(T)].Push(block);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs b/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..4a8f16d
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Mono.Addins;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Region.ClientStack.LindenUDP")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("9d3dbc6b-9d85-483b-af48-c1dfc261b7ac")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion(OpenSim.VersionInfo.AssemblyVersionNumber)]
+
+[assembly: Addin("LindenUDP", OpenSim.VersionInfo.VersionNumber)]
+[assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
new file mode 100644
index 0000000..eb262d2
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
@@ -0,0 +1,273 @@
+/*
+ * 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.Net;
+using log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    /// <summary>
+    /// This will contain basic tests for the LindenUDP client stack
+    /// </summary>
+    [TestFixture]
+    public class BasicCircuitTests : OpenSimTestCase
+    {
+        private Scene m_scene;
+
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
+        }
+
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten so none of them require async stuff (which regression
+            // tests really shouldn't).
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
+
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+            m_scene = new SceneHelpers().SetupScene();
+            StatsManager.SimExtraStats = new SimExtraStatsCollector();
+        }
+
+//        /// <summary>
+//        /// Build an object name packet for test purposes
+//        /// </summary>
+//        /// <param name="objectLocalId"></param>
+//        /// <param name="objectName"></param>
+//        private ObjectNamePacket BuildTestObjectNamePacket(uint objectLocalId, string objectName)
+//        {
+//            ObjectNamePacket onp = new ObjectNamePacket();
+//            ObjectNamePacket.ObjectDataBlock odb = new ObjectNamePacket.ObjectDataBlock();
+//            odb.LocalID = objectLocalId;
+//            odb.Name = Utils.StringToBytes(objectName);
+//            onp.ObjectData = new ObjectNamePacket.ObjectDataBlock[] { odb };
+//            onp.Header.Zerocoded = false;
+//
+//            return onp;
+//        }
+//
+        /// <summary>
+        /// Test adding a client to the stack
+        /// </summary>
+/*        
+        [Test]
+        public void TestAddClient()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(m_scene);
+
+            UUID myAgentUuid   = TestHelpers.ParseTail(0x1);
+            UUID mySessionUuid = TestHelpers.ParseTail(0x2);
+            uint myCircuitCode = 123456;
+            IPEndPoint testEp = new IPEndPoint(IPAddress.Loopback, 999);
+
+            UseCircuitCodePacket uccp = new UseCircuitCodePacket();
+
+            UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock
+                = new UseCircuitCodePacket.CircuitCodeBlock();
+            uccpCcBlock.Code = myCircuitCode;
+            uccpCcBlock.ID = myAgentUuid;
+            uccpCcBlock.SessionID = mySessionUuid;
+            uccp.CircuitCode = uccpCcBlock;
+
+            byte[] uccpBytes = uccp.ToBytes();
+            UDPPacketBuffer upb = new UDPPacketBuffer(testEp, uccpBytes.Length);
+            upb.DataLength = uccpBytes.Length;  // God knows why this isn't set by the constructor.
+            Buffer.BlockCopy(uccpBytes, 0, upb.Data, 0, uccpBytes.Length);
+
+            udpServer.PacketReceived(upb);
+
+            // Presence shouldn't exist since the circuit manager doesn't know about this circuit for authentication yet
+            Assert.That(m_scene.GetScenePresence(myAgentUuid), Is.Null);
+
+            AgentCircuitData acd = new AgentCircuitData();
+            acd.AgentID = myAgentUuid;
+            acd.SessionID = mySessionUuid;
+
+            m_scene.AuthenticateHandler.AddNewCircuit(myCircuitCode, acd);
+
+            udpServer.PacketReceived(upb);
+
+            // Should succeed now
+            ScenePresence sp = m_scene.GetScenePresence(myAgentUuid);
+            Assert.That(sp.UUID, Is.EqualTo(myAgentUuid));
+
+            Assert.That(udpServer.PacketsSent.Count, Is.EqualTo(1));
+
+            Packet packet = udpServer.PacketsSent[0];
+            Assert.That(packet, Is.InstanceOf(typeof(PacketAckPacket)));
+
+            PacketAckPacket ackPacket = packet as PacketAckPacket;
+            Assert.That(ackPacket.Packets.Length, Is.EqualTo(1));
+            Assert.That(ackPacket.Packets[0].ID, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void TestLogoutClientDueToAck()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            IniConfigSource ics = new IniConfigSource();
+            IConfig config = ics.AddConfig("ClientStack.LindenUDP");
+            config.Set("AckTimeout", -1);
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(m_scene, ics);
+
+            ScenePresence sp
+                = ClientStackHelpers.AddChildClient(
+                    m_scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            udpServer.ClientOutgoingPacketHandler(sp.ControllingClient, true, false, false);
+
+            ScenePresence spAfterAckTimeout = m_scene.GetScenePresence(sp.UUID);
+            Assert.That(spAfterAckTimeout, Is.Null);
+        }
+*/
+//        /// <summary>
+//        /// Test removing a client from the stack
+//        /// </summary>
+//        [Test]
+//        public void TestRemoveClient()
+//        {
+//            TestHelper.InMethod();
+//
+//            uint myCircuitCode = 123457;
+//
+//            TestLLUDPServer testLLUDPServer;
+//            TestLLPacketServer testLLPacketServer;
+//            AgentCircuitManager acm;
+//            SetupStack(new MockScene(), out testLLUDPServer, out testLLPacketServer, out acm);
+//            AddClient(myCircuitCode, new IPEndPoint(IPAddress.Loopback, 1000), testLLUDPServer, acm);
+//
+//            testLLUDPServer.RemoveClientCircuit(myCircuitCode);
+//            Assert.IsFalse(testLLUDPServer.HasCircuit(myCircuitCode));
+//
+//            // Check that removing a non-existent circuit doesn't have any bad effects
+//            testLLUDPServer.RemoveClientCircuit(101);
+//            Assert.IsFalse(testLLUDPServer.HasCircuit(101));
+//        }
+//
+//        /// <summary>
+//        /// Make sure that the client stack reacts okay to malformed packets
+//        /// </summary>
+//        [Test]
+//        public void TestMalformedPacketSend()
+//        {
+//            TestHelper.InMethod();
+//
+//            uint myCircuitCode = 123458;
+//            EndPoint testEp = new IPEndPoint(IPAddress.Loopback, 1001);
+//            MockScene scene = new MockScene();
+//
+//            TestLLUDPServer testLLUDPServer;
+//            TestLLPacketServer testLLPacketServer;
+//            AgentCircuitManager acm;
+//            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
+//            AddClient(myCircuitCode, testEp, testLLUDPServer, acm);
+//
+//            byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };
+//
+//            // Send two garbled 'packets' in succession
+//            testLLUDPServer.LoadReceive(data, testEp);
+//            testLLUDPServer.LoadReceive(data, testEp);
+//            testLLUDPServer.ReceiveData(null);
+//
+//            // Check that we are still here
+//            Assert.IsTrue(testLLUDPServer.HasCircuit(myCircuitCode));
+//            Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(0));
+//
+//            // Check that sending a valid packet to same circuit still succeeds
+//            Assert.That(scene.ObjectNameCallsReceived, Is.EqualTo(0));
+//
+//            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "helloooo"), testEp);
+//            testLLUDPServer.ReceiveData(null);
+//
+//            Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(1));
+//            Assert.That(testLLPacketServer.GetPacketsReceivedFor(PacketType.ObjectName), Is.EqualTo(1));
+//        }
+//
+//        /// <summary>
+//        /// Test that the stack continues to work even if some client has caused a
+//        /// SocketException on Socket.BeginReceive()
+//        /// </summary>
+//        [Test]
+//        public void TestExceptionOnBeginReceive()
+//        {
+//            TestHelper.InMethod();
+//
+//            MockScene scene = new MockScene();
+//
+//            uint circuitCodeA = 130000;
+//            EndPoint epA = new IPEndPoint(IPAddress.Loopback, 1300);
+//            UUID agentIdA   = UUID.Parse("00000000-0000-0000-0000-000000001300");
+//            UUID sessionIdA = UUID.Parse("00000000-0000-0000-0000-000000002300");
+//
+//            uint circuitCodeB = 130001;
+//            EndPoint epB = new IPEndPoint(IPAddress.Loopback, 1301);
+//            UUID agentIdB   = UUID.Parse("00000000-0000-0000-0000-000000001301");
+//            UUID sessionIdB = UUID.Parse("00000000-0000-0000-0000-000000002301");
+//
+//            TestLLUDPServer testLLUDPServer;
+//            TestLLPacketServer testLLPacketServer;
+//            AgentCircuitManager acm;
+//            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
+//            AddClient(circuitCodeA, epA, agentIdA, sessionIdA, testLLUDPServer, acm);
+//            AddClient(circuitCodeB, epB, agentIdB, sessionIdB, testLLUDPServer, acm);
+//
+//            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "packet1"), epA);
+//            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "packet2"), epB);
+//            testLLUDPServer.LoadReceiveWithBeginException(epA);
+//            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(2, "packet3"), epB);
+//            testLLUDPServer.ReceiveData(null);
+//
+//            Assert.IsFalse(testLLUDPServer.HasCircuit(circuitCodeA));
+//
+//            Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(3));
+//            Assert.That(testLLPacketServer.GetPacketsReceivedFor(PacketType.ObjectName), Is.EqualTo(3));
+//        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/LLImageManagerTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/LLImageManagerTests.cs
new file mode 100644
index 0000000..6c57e6d
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/LLImageManagerTests.cs
@@ -0,0 +1,174 @@
+/*
+ * 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.Net;
+using System.Reflection;
+using System.Threading;
+using log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.CoreModules.Agent.TextureSender;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    [TestFixture]
+    public class LLImageManagerTests : OpenSimTestCase
+    {
+        private AssetBase m_testImageAsset;
+        private Scene scene;
+        private LLImageManager llim;
+        private TestClient tc;
+
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            Util.FireAndForgetMethod = FireAndForgetMethod.None;
+
+            using (
+                Stream resource
+                    = GetType().Assembly.GetManifestResourceStream(
+                        "OpenSim.Region.ClientStack.LindenUDP.Tests.Resources.4-tile2.jp2"))
+            {
+                using (BinaryReader br = new BinaryReader(resource))
+                {
+                    m_testImageAsset
+                        = new AssetBase(
+                            TestHelpers.ParseTail(0x1),
+                            "Test Image",
+                            (sbyte)AssetType.Texture,
+                            TestHelpers.ParseTail(0x2).ToString());
+
+                    m_testImageAsset.Data = br.ReadBytes(99999999);
+                }
+            }
+        }
+
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten not to worry about such things.
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
+
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            UUID userId = TestHelpers.ParseTail(0x3);
+
+            J2KDecoderModule j2kdm = new J2KDecoderModule();
+
+            SceneHelpers sceneHelpers = new SceneHelpers();
+            scene = sceneHelpers.SetupScene();
+            SceneHelpers.SetupSceneModules(scene, j2kdm);
+
+            tc = new TestClient(SceneHelpers.GenerateAgentData(userId), scene);
+            llim = new LLImageManager(tc, scene.AssetService, j2kdm);
+        }
+
+        [Test]
+        public void TestSendImage()
+        {
+            TestHelpers.InMethod();
+//            XmlConfigurator.Configure();
+
+            scene.AssetService.Store(m_testImageAsset);
+
+            TextureRequestArgs args = new TextureRequestArgs();
+            args.RequestedAssetID = m_testImageAsset.FullID;
+            args.DiscardLevel = 0;
+            args.PacketNumber = 1;
+            args.Priority = 5;
+            args.requestSequence = 1;
+
+            llim.EnqueueReq(args);
+            llim.ProcessImageQueue(20);
+
+            Assert.That(tc.SentImageDataPackets.Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestDiscardImage()
+        {
+            TestHelpers.InMethod();
+//            XmlConfigurator.Configure();
+
+            scene.AssetService.Store(m_testImageAsset);
+
+            TextureRequestArgs args = new TextureRequestArgs();
+            args.RequestedAssetID = m_testImageAsset.FullID;
+            args.DiscardLevel = 0;
+            args.PacketNumber = 1;
+            args.Priority = 5;
+            args.requestSequence = 1;
+            llim.EnqueueReq(args);
+
+            // Now create a discard request
+            TextureRequestArgs discardArgs = new TextureRequestArgs();
+            discardArgs.RequestedAssetID = m_testImageAsset.FullID;
+            discardArgs.DiscardLevel = -1;
+            discardArgs.PacketNumber = 1;
+            discardArgs.Priority = 0;
+            discardArgs.requestSequence = 2;
+            llim.EnqueueReq(discardArgs);
+
+            llim.ProcessImageQueue(20);
+
+            Assert.That(tc.SentImageDataPackets.Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void TestMissingImage()
+        {
+            TestHelpers.InMethod();
+//            XmlConfigurator.Configure();
+
+            TextureRequestArgs args = new TextureRequestArgs();
+            args.RequestedAssetID = m_testImageAsset.FullID;
+            args.DiscardLevel = 0;
+            args.PacketNumber = 1;
+            args.Priority = 5;
+            args.requestSequence = 1;
+
+            llim.EnqueueReq(args);
+            llim.ProcessImageQueue(20);
+
+            Assert.That(tc.SentImageDataPackets.Count, Is.EqualTo(0));
+            Assert.That(tc.SentImageNotInDatabasePackets.Count, Is.EqualTo(1));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
new file mode 100644
index 0000000..1731aa9
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
@@ -0,0 +1,104 @@
+/*
+ * 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 Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    /// <summary>
+    /// Tests for the LL packet handler
+    /// </summary>
+    [TestFixture]
+    public class PacketHandlerTests : OpenSimTestCase
+    {
+//        [Test]
+//        /// <summary>
+//        /// More a placeholder, really
+//        /// </summary>
+//        public void InPacketTest()
+//        {
+//            TestHelper.InMethod();
+//
+//            AgentCircuitData agent = new AgentCircuitData();
+//            agent.AgentID = UUID.Random();
+//            agent.firstname = "testfirstname";
+//            agent.lastname = "testlastname";
+//            agent.SessionID = UUID.Zero;
+//            agent.SecureSessionID = UUID.Zero;
+//            agent.circuitcode = 123;
+//            agent.BaseFolder = UUID.Zero;
+//            agent.InventoryFolder = UUID.Zero;
+//            agent.startpos = Vector3.Zero;
+//            agent.CapsPath = "http://wibble.com";
+//
+//            TestLLUDPServer testLLUDPServer;
+//            TestLLPacketServer testLLPacketServer;
+//            AgentCircuitManager acm;
+//            IScene scene = new MockScene();
+//            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
+//
+//            TestClient testClient = new TestClient(agent, scene);
+//
+//            LLPacketHandler packetHandler
+//                = new LLPacketHandler(testClient, testLLPacketServer, new ClientStackUserSettings());
+//
+//            packetHandler.InPacket(new AgentAnimationPacket());
+//            LLQueItem receivedPacket = packetHandler.PacketQueue.Dequeue();
+//
+//            Assert.That(receivedPacket, Is.Not.Null);
+//            Assert.That(receivedPacket.Incoming, Is.True);
+//            Assert.That(receivedPacket.Packet, Is.TypeOf(typeof(AgentAnimationPacket)));
+//        }
+//
+//        /// <summary>
+//        /// Add a client for testing
+//        /// </summary>
+//        /// <param name="scene"></param>
+//        /// <param name="testLLUDPServer"></param>
+//        /// <param name="testPacketServer"></param>
+//        /// <param name="acm">Agent circuit manager used in setting up the stack</param>
+//        protected void SetupStack(
+//            IScene scene, out TestLLUDPServer testLLUDPServer, out TestLLPacketServer testPacketServer,
+//            out AgentCircuitManager acm)
+//        {
+//            IConfigSource configSource = new IniConfigSource();
+//            ClientStackUserSettings userSettings = new ClientStackUserSettings();
+//            testLLUDPServer = new TestLLUDPServer();
+//            acm = new AgentCircuitManager();
+//
+//            uint port = 666;
+//            testLLUDPServer.Initialise(null, ref port, 0, false, configSource, acm);
+//            testPacketServer = new TestLLPacketServer(testLLUDPServer, userSettings);
+//            testLLUDPServer.LocalScene = scene;
+//        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/Resources/4-tile2.jp2 b/OpenSim/Region/ClientStack/Linden/UDP/Tests/Resources/4-tile2.jp2
new file mode 100644
index 0000000..8c63104
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/Resources/4-tile2.jp2
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs
new file mode 100644
index 0000000..873b1e5
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs
@@ -0,0 +1,432 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    /*
+    [TestFixture]
+    public class ThrottleTests : OpenSimTestCase
+    {
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
+        }
+
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten so none of them require async stuff (which regression
+            // tests really shouldn't).
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
+
+        [Test]
+        public void TestSetRequestDripRate()
+        {
+
+            TestHelpers.InMethod();
+
+            TokenBucket tb = new TokenBucket(null, 5000f,10000f);
+            AssertRates(tb, 5000, 0, 5000, 0);
+
+            tb.RequestedDripRate = 4000f;
+            AssertRates(tb, 4000, 0, 4000, 0);
+
+            tb.RequestedDripRate = 6000;
+            AssertRates(tb, 6000, 0, 6000, 0);
+
+        }
+
+        [Test]
+        public void TestSetRequestDripRateWithMax()
+        {
+            TestHelpers.InMethod();
+
+            TokenBucket tb = new TokenBucket(null, 5000,15000);
+            AssertRates(tb, 5000, 0, 5000, 10000);
+
+            tb.RequestedDripRate = 4000;
+            AssertRates(tb, 4000, 0, 4000, 10000);
+
+            tb.RequestedDripRate = 6000;
+            AssertRates(tb, 6000, 0, 6000, 10000);
+
+            tb.RequestedDripRate = 12000;
+            AssertRates(tb, 10000, 0, 10000, 10000);
+        }
+
+        [Test]
+        public void TestSetRequestDripRateWithChildren()
+        {
+            TestHelpers.InMethod();
+
+            TokenBucket tbParent = new TokenBucket("tbParent", null, 0);
+            TokenBucket tbChild1 = new TokenBucket("tbChild1", tbParent, 3000);
+            TokenBucket tbChild2 = new TokenBucket("tbChild2", tbParent, 5000);
+
+            AssertRates(tbParent, 8000, 8000, 8000, 0);
+            AssertRates(tbChild1, 3000, 0, 3000, 0);
+            AssertRates(tbChild2, 5000, 0, 5000, 0);
+
+            // Test: Setting a parent request greater than total children requests.
+            tbParent.RequestedDripRate = 10000;
+
+            AssertRates(tbParent, 10000, 8000, 8000, 0);
+            AssertRates(tbChild1, 3000, 0, 3000, 0);
+            AssertRates(tbChild2, 5000, 0, 5000, 0);
+
+            // Test: Setting a parent request lower than total children requests.
+            tbParent.RequestedDripRate = 6000;
+
+            AssertRates(tbParent, 6000, 8000, 6000, 0);
+            AssertRates(tbChild1, 3000, 0, 6000 / 8 * 3, 0);
+            AssertRates(tbChild2, 5000, 0, 6000 / 8 * 5, 0);
+
+        }
+
+        private void AssertRates(
+            TokenBucket tb, double requestedDripRate, double totalDripRequest, double dripRate, double maxDripRate)
+        {
+            Assert.AreEqual((int)requestedDripRate, tb.RequestedDripRate, "Requested drip rate");
+            Assert.AreEqual((int)totalDripRequest, tb.TotalDripRequest, "Total drip request");
+            Assert.AreEqual((int)dripRate, tb.DripRate, "Drip rate");
+            Assert.AreEqual((int)maxDripRate, tb.MaxDripRate, "Max drip rate");
+        }
+
+        [Test]
+        public void TestClientThrottleSetNoLimit()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            Scene scene = new SceneHelpers().SetupScene();
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene);
+
+            ScenePresence sp
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+
+            udpServer.Throttle.DebugLevel = 1;
+            udpClient.ThrottleDebugLevel = 1;
+
+            int resendBytes = 1000;
+            int landBytes = 2000;
+            int windBytes = 3000;
+            int cloudBytes = 4000;
+            int taskBytes = 5000;
+            int textureBytes = 6000;
+            int assetBytes = 7000;
+
+            SetThrottles(
+                udpClient, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            // We expect this to be lower because of the minimum bound set by MTU
+            int totalBytes = LLUDPServer.MTU + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes;
+
+            AssertThrottles(
+                udpClient,
+                LLUDPServer.MTU, landBytes, windBytes, cloudBytes, taskBytes,
+                textureBytes, assetBytes, totalBytes, 0, 0);
+        }
+
+        [Test]
+        public void TestClientThrottleAdaptiveNoLimit()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            Scene scene = new SceneHelpers().SetupScene();
+
+            IniConfigSource ics = new IniConfigSource();
+            IConfig config = ics.AddConfig("ClientStack.LindenUDP");
+            config.Set("enable_adaptive_throttles", true);
+            config.Set("adaptive_throttle_min_bps", 32000);
+
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene, ics);
+
+            ScenePresence sp
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+
+            udpServer.Throttle.DebugLevel = 1;
+            udpClient.ThrottleDebugLevel = 1;
+
+            // Total is 275000
+            int resendBytes = 5000; // this is set low to test the minimum throttle override
+            int landBytes = 20000;
+            int windBytes = 30000;
+            int cloudBytes = 40000;
+            int taskBytes = 50000;
+            int textureBytes = 60000;
+            int assetBytes = 70000;
+            int totalBytes = resendBytes + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes;
+
+            SetThrottles(
+                udpClient, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            // Ratio of current adaptive drip rate to requested bytes, minimum rate is 32000
+            double commitRatio = 32000.0 / totalBytes;
+
+            AssertThrottles(
+                udpClient,
+                LLUDPServer.MTU, landBytes * commitRatio, windBytes * commitRatio, cloudBytes * commitRatio, taskBytes * commitRatio,
+                textureBytes * commitRatio, assetBytes * commitRatio, udpClient.FlowThrottle.AdjustedDripRate, totalBytes, 0);
+
+            // Test an increase in target throttle, ack of 20 packets adds 20 * LLUDPServer.MTU bytes
+            // to the throttle, recompute commitratio from those numbers
+            udpClient.FlowThrottle.AcknowledgePackets(20);
+            commitRatio = (32000.0 + 20.0 * LLUDPServer.MTU) / totalBytes;
+
+            AssertThrottles(
+                udpClient,
+                LLUDPServer.MTU, landBytes * commitRatio, windBytes * commitRatio, cloudBytes * commitRatio, taskBytes * commitRatio,
+                textureBytes * commitRatio, assetBytes * commitRatio, udpClient.FlowThrottle.AdjustedDripRate, totalBytes, 0);
+
+            // Test a decrease in target throttle, adaptive throttle should cut the rate by 50% with a floor
+            // set by the minimum adaptive rate
+            udpClient.FlowThrottle.ExpirePackets(1);
+            commitRatio = (32000.0 + (20.0 * LLUDPServer.MTU)/Math.Pow(2,1)) / totalBytes;
+
+            AssertThrottles(
+                udpClient,
+                LLUDPServer.MTU, landBytes * commitRatio, windBytes * commitRatio, cloudBytes * commitRatio, taskBytes * commitRatio,
+                textureBytes * commitRatio, assetBytes * commitRatio, udpClient.FlowThrottle.AdjustedDripRate, totalBytes, 0);
+        }
+
+        /// <summary>
+        /// Test throttle setttings where max client throttle has been limited server side.
+        /// </summary>
+        [Test]
+        public void TestSingleClientThrottleRegionLimited()
+        {
+            TestHelpers.InMethod();
+            //            TestHelpers.EnableLogging();
+
+            int resendBytes = 6000;
+            int landBytes = 8000;
+            int windBytes = 10000;
+            int cloudBytes = 12000;
+            int taskBytes = 14000;
+            int textureBytes = 16000;
+            int assetBytes = 18000;
+            int totalBytes
+                = (int)((resendBytes + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes) / 2);
+
+            Scene scene = new SceneHelpers().SetupScene();
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene);
+            udpServer.Throttle.RequestedDripRate = totalBytes;
+
+            ScenePresence sp1
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient1 = ((LLClientView)sp1.ControllingClient).UDPClient;
+
+            SetThrottles(
+                udpClient1, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient1,
+                resendBytes / 2, landBytes / 2, windBytes / 2, cloudBytes / 2, taskBytes / 2,
+                textureBytes / 2, assetBytes / 2, totalBytes, 0, 0);
+
+            // Test: Now add another client
+            ScenePresence sp2
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x10), TestHelpers.ParseTail(0x20), 123457);
+
+            LLUDPClient udpClient2 = ((LLClientView)sp2.ControllingClient).UDPClient;
+            //            udpClient.ThrottleDebugLevel = 1;
+
+            SetThrottles(
+                udpClient2, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient1,
+                resendBytes / 4, landBytes / 4, windBytes / 4, cloudBytes / 4, taskBytes / 4,
+                textureBytes / 4, assetBytes / 4, totalBytes / 2, 0, 0);
+
+            AssertThrottles(
+                udpClient2,
+                resendBytes / 4, landBytes / 4, windBytes / 4, cloudBytes / 4, taskBytes / 4,
+                textureBytes / 4, assetBytes / 4, totalBytes / 2, 0, 0);
+        }
+
+        /// <summary>
+        /// Test throttle setttings where max client throttle has been limited server side.
+        /// </summary>
+        [Test]
+        public void TestClientThrottlePerClientLimited()
+        {
+            TestHelpers.InMethod();
+            //            TestHelpers.EnableLogging();
+
+            int resendBytes = 4000;
+            int landBytes = 6000;
+            int windBytes = 8000;
+            int cloudBytes = 10000;
+            int taskBytes = 12000;
+            int textureBytes = 14000;
+            int assetBytes = 16000;
+            int totalBytes
+                = (int)((resendBytes + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes) / 2);
+
+            Scene scene = new SceneHelpers().SetupScene();
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene);
+            udpServer.ThrottleRates.Total = totalBytes;
+
+            ScenePresence sp
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
+            //            udpClient.ThrottleDebugLevel = 1;
+
+            SetThrottles(
+                udpClient, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient,
+                resendBytes / 2, landBytes / 2, windBytes / 2, cloudBytes / 2, taskBytes / 2,
+                textureBytes / 2, assetBytes / 2, totalBytes, 0, totalBytes);
+        }
+
+        [Test]
+        public void TestClientThrottlePerClientAndRegionLimited()
+        {
+            TestHelpers.InMethod();
+            //TestHelpers.EnableLogging();
+
+            int resendBytes = 4000;
+            int landBytes = 6000;
+            int windBytes = 8000;
+            int cloudBytes = 10000;
+            int taskBytes = 12000;
+            int textureBytes = 14000;
+            int assetBytes = 16000;
+
+            // current total 70000
+            int totalBytes = resendBytes + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes;
+
+            Scene scene = new SceneHelpers().SetupScene();
+            TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene);
+            udpServer.ThrottleRates.Total = (int)(totalBytes * 1.1);
+            udpServer.Throttle.RequestedDripRate = (int)(totalBytes * 1.5);
+
+            ScenePresence sp1
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
+
+            LLUDPClient udpClient1 = ((LLClientView)sp1.ControllingClient).UDPClient;
+            udpClient1.ThrottleDebugLevel = 1;
+
+            SetThrottles(
+                udpClient1, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient1,
+                resendBytes, landBytes, windBytes, cloudBytes, taskBytes,
+                textureBytes, assetBytes, totalBytes, 0, totalBytes * 1.1);
+
+            // Now add another client
+            ScenePresence sp2
+                = ClientStackHelpers.AddChildClient(
+                    scene, udpServer, TestHelpers.ParseTail(0x10), TestHelpers.ParseTail(0x20), 123457);
+
+            LLUDPClient udpClient2 = ((LLClientView)sp2.ControllingClient).UDPClient;
+            udpClient2.ThrottleDebugLevel = 1;
+
+            SetThrottles(
+                udpClient2, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
+
+            AssertThrottles(
+                udpClient1,
+                resendBytes * 0.75, landBytes * 0.75, windBytes * 0.75, cloudBytes * 0.75, taskBytes * 0.75,
+                textureBytes * 0.75, assetBytes * 0.75, totalBytes * 0.75, 0, totalBytes * 1.1);
+
+            AssertThrottles(
+                udpClient2,
+                resendBytes * 0.75, landBytes * 0.75, windBytes * 0.75, cloudBytes * 0.75, taskBytes * 0.75,
+                textureBytes * 0.75, assetBytes * 0.75, totalBytes * 0.75, 0, totalBytes * 1.1);
+        }
+
+        private void AssertThrottles(
+            LLUDPClient udpClient,
+            double resendBytes, double landBytes, double windBytes, double cloudBytes, double taskBytes, double textureBytes, double assetBytes,
+            double totalBytes, double targetBytes, double maxBytes)
+        {
+            ClientInfo ci = udpClient.GetClientInfo();
+
+//                            Console.WriteLine(
+//                                "Resend={0}, Land={1}, Wind={2}, Cloud={3}, Task={4}, Texture={5}, Asset={6}, TOTAL = {7}",
+//                                ci.resendThrottle, ci.landThrottle, ci.windThrottle, ci.cloudThrottle, ci.taskThrottle, ci.textureThrottle, ci.assetThrottle, ci.totalThrottle);
+
+            Assert.AreEqual((int)resendBytes, ci.resendThrottle, "Resend");
+            Assert.AreEqual((int)landBytes, ci.landThrottle, "Land");
+            Assert.AreEqual((int)windBytes, ci.windThrottle, "Wind");
+            Assert.AreEqual((int)cloudBytes, ci.cloudThrottle, "Cloud");
+            Assert.AreEqual((int)taskBytes, ci.taskThrottle, "Task");
+            Assert.AreEqual((int)textureBytes, ci.textureThrottle, "Texture");
+            Assert.AreEqual((int)assetBytes, ci.assetThrottle, "Asset");
+            Assert.AreEqual((int)totalBytes, ci.totalThrottle, "Total");
+            Assert.AreEqual((int)targetBytes, ci.targetThrottle, "Target");
+            Assert.AreEqual((int)maxBytes, ci.maxThrottle, "Max");
+        }
+
+        private void SetThrottles(
+            LLUDPClient udpClient, int resendBytes, int landBytes, int windBytes, int cloudBytes, int taskBytes, int textureBytes, int assetBytes)
+        {
+            byte[] throttles = new byte[28];
+
+            Array.Copy(BitConverter.GetBytes((float)resendBytes * 8), 0, throttles, 0, 4);
+            Array.Copy(BitConverter.GetBytes((float)landBytes * 8), 0, throttles, 4, 4);
+            Array.Copy(BitConverter.GetBytes((float)windBytes * 8), 0, throttles, 8, 4);
+            Array.Copy(BitConverter.GetBytes((float)cloudBytes * 8), 0, throttles, 12, 4);
+            Array.Copy(BitConverter.GetBytes((float)taskBytes * 8), 0, throttles, 16, 4);
+            Array.Copy(BitConverter.GetBytes((float)textureBytes * 8), 0, throttles, 20, 4);
+            Array.Copy(BitConverter.GetBytes((float)assetBytes * 8), 0, throttles, 24, 4);
+
+            udpClient.SetThrottles(throttles);
+        }
+    }
+     */
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/ThrottleRates.cs b/OpenSim/Region/ClientStack/Linden/UDP/ThrottleRates.cs
new file mode 100644
index 0000000..f8ec97a
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/ThrottleRates.cs
@@ -0,0 +1,141 @@
+/*
+ * 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 OpenSim.Framework;
+using Nini.Config;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    /// <summary>
+    /// Holds drip rates and maximum burst rates for throttling with hierarchical
+    /// token buckets. The maximum burst rates set here are hard limits and can
+    /// not be overridden by client requests
+    /// </summary>
+    public sealed class ThrottleRates
+    {
+        /// <summary>Drip rate for resent packets</summary>
+        public int Resend;
+        /// <summary>Drip rate for terrain packets</summary>
+        public int Land;
+        /// <summary>Drip rate for wind packets</summary>
+        public int Wind;
+        /// <summary>Drip rate for cloud packets</summary>
+        public int Cloud;
+        /// <summary>Drip rate for task packets</summary>
+        public int Task;
+        /// <summary>Drip rate for texture packets</summary>
+        public int Texture;
+        /// <summary>Drip rate for asset packets</summary>
+        public int Asset;
+
+        /// <summary>Drip rate for the parent token bucket</summary>
+        public int Total;
+
+        /// <summary>Flag used to enable adaptive throttles</summary>
+        public bool AdaptiveThrottlesEnabled;
+
+        /// <summary>
+        /// Set the minimum rate that the adaptive throttles can set. The viewer
+        /// can still throttle lower than this, but the adaptive throttles will
+        /// never decrease rates below this no matter how many packets are dropped
+        /// </summary>
+        public Int64 MinimumAdaptiveThrottleRate;
+
+        /// <summary>Amount of the texture throttle to steal for the task throttle</summary>
+        public double CannibalizeTextureRate;
+
+        public int ClientMaxRate;
+        public float BrustTime;
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="config">Config source to load defaults from</param>
+        public ThrottleRates(IConfigSource config)
+        {
+            try
+            {
+                IConfig throttleConfig = config.Configs["ClientStack.LindenUDP"];
+
+                // Current default total is 66750
+                Resend = throttleConfig.GetInt("resend_default", 6625);
+                Land = throttleConfig.GetInt("land_default", 9125);
+                Wind = throttleConfig.GetInt("wind_default", 1750);
+                Cloud = throttleConfig.GetInt("cloud_default", 1750);
+                Task = throttleConfig.GetInt("task_default", 18500);
+                Texture = throttleConfig.GetInt("texture_default", 18500);
+                Asset = throttleConfig.GetInt("asset_default", 10500);
+
+                Total = Resend + Land + Wind + Cloud + Task + Texture + Asset;
+                // 5120000 bps default max
+                ClientMaxRate = throttleConfig.GetInt("client_throttle_max_bps", 640000);
+                if (ClientMaxRate > 1000000)
+                    ClientMaxRate = 1000000; // no more than 8Mbps
+
+                BrustTime = (float)throttleConfig.GetInt("client_throttle_burtsTimeMS", 10);
+                BrustTime *= 1e-3f;
+
+                // Adaptive is broken
+//                AdaptiveThrottlesEnabled = throttleConfig.GetBoolean("enable_adaptive_throttles", false);
+                AdaptiveThrottlesEnabled = false;
+                MinimumAdaptiveThrottleRate = throttleConfig.GetInt("adaptive_throttle_min_bps", 32000);
+
+                // http textures do use udp bandwidth setting
+//                CannibalizeTextureRate = (double)throttleConfig.GetFloat("CannibalizeTextureRate", 0.0f);
+//                CannibalizeTextureRate = Util.Clamp<double>(CannibalizeTextureRate,0.0, 0.9);
+                CannibalizeTextureRate = 0f;
+
+            }
+            catch (Exception) { }
+        }
+
+        public int GetRate(ThrottleOutPacketType type)
+        {
+            switch (type)
+            {
+                case ThrottleOutPacketType.Resend:
+                    return Resend;
+                case ThrottleOutPacketType.Land:
+                    return Land;
+                case ThrottleOutPacketType.Wind:
+                    return Wind;
+                case ThrottleOutPacketType.Cloud:
+                    return Cloud;
+                case ThrottleOutPacketType.Task:
+                    return Task;
+                case ThrottleOutPacketType.Texture:
+                    return Texture;
+                case ThrottleOutPacketType.Asset:
+                    return Asset;
+                case ThrottleOutPacketType.Unknown:
+                default:
+                    return 0;
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs b/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
new file mode 100644
index 0000000..1daf091
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
@@ -0,0 +1,417 @@
+/*
+ * 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 OpenSim.Framework;
+
+using log4net;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    /// <summary>
+    /// A hierarchical token bucket for bandwidth throttling. See
+    /// http://en.wikipedia.org/wiki/Token_bucket for more information
+    /// </summary>
+    public class TokenBucket
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static Int32 m_counter = 0;
+
+//        private Int32 m_identifier;
+
+        protected const float m_timeScale = 1e-3f;
+
+        /// <summary>
+        /// This is the number of m_minimumDripRate bytes
+        /// allowed in a burst
+        /// roughtly, with this settings, the maximum time system will take
+        /// to recheck a bucket in ms
+        ///
+        /// </summary>
+        protected const float m_quantumsPerBurst = 5;
+
+        /// <summary>
+        /// </summary>
+        protected const float m_minimumDripRate = 1500;
+
+        /// <summary>Time of the last drip</summary>
+        protected double m_lastDrip;
+
+        /// <summary>
+        /// The number of bytes that can be sent at this moment. This is the
+        /// current number of tokens in the bucket
+        /// </summary>
+        protected float m_tokenCount;
+
+        /// <summary>
+        /// Map of children buckets and their requested maximum burst rate
+        /// </summary>
+
+        protected Dictionary<TokenBucket, float> m_children = new Dictionary<TokenBucket, float>();
+
+#region Properties
+
+        /// <summary>
+        /// The parent bucket of this bucket, or null if this bucket has no
+        /// parent. The parent bucket will limit the aggregate bandwidth of all
+        /// of its children buckets
+        /// </summary>
+        protected TokenBucket m_parent;
+        public TokenBucket Parent
+        {
+            get { return m_parent; }
+            set { m_parent = value; }
+        }
+        /// <summary>
+        /// This is the maximum number
+        /// of tokens that can accumulate in the bucket at any one time. This
+        /// also sets the total request for leaf nodes
+        /// </summary>
+        protected float m_burst;
+
+        protected float m_maxDripRate = 0;
+        public virtual float MaxDripRate
+        {
+            get { return m_maxDripRate; }
+            set { m_maxDripRate = value; }
+        }
+
+        public float RequestedBurst
+        {
+            get { return m_burst; }
+            set {
+                float rate = (value < 0 ? 0 : value);
+                if (rate < 1.5f * m_minimumDripRate)
+                    rate = 1.5f * m_minimumDripRate;
+                else if (rate > m_minimumDripRate * m_quantumsPerBurst)
+                    rate = m_minimumDripRate * m_quantumsPerBurst;
+
+                m_burst = rate;
+                }
+        }
+
+        public float Burst
+        {
+            get {
+                float rate = RequestedBurst * BurstModifier();
+                if (rate < m_minimumDripRate)
+                    rate = m_minimumDripRate;
+                return (float)rate;
+            }
+        }
+
+        /// <summary>
+        /// The requested drip rate for this particular bucket.
+        /// </summary>
+        /// <remarks>
+        /// 0 then TotalDripRequest is used instead.
+        /// Can never be above MaxDripRate.
+        /// Tokens are added to the bucket at any time
+        /// <seealso cref="RemoveTokens"/> is called, at the granularity of
+        /// the system tick interval (typically around 15-22ms)</remarks>
+        protected float m_dripRate;
+
+        public float RequestedDripRate
+        {
+            get { return (m_dripRate == 0 ? m_totalDripRequest : m_dripRate); }
+            set {
+                m_dripRate = (value < 0 ? 0 : value);
+                m_totalDripRequest = m_dripRate;
+
+                if (m_parent != null)
+                    m_parent.RegisterRequest(this,m_dripRate);
+            }
+        }
+
+       public float DripRate
+        {
+            get {
+                float rate = Math.Min(RequestedDripRate,TotalDripRequest);
+                if (m_parent == null)
+                    return rate;
+
+                rate *= m_parent.DripRateModifier();
+                if (rate < m_minimumDripRate)
+                    rate = m_minimumDripRate;
+
+                return (float)rate;
+            }
+        }
+
+        /// <summary>
+        /// The current total of the requested maximum burst rates of children buckets.
+        /// </summary>
+        protected float m_totalDripRequest;
+        public float TotalDripRequest
+        {
+            get { return m_totalDripRequest; }
+            set { m_totalDripRequest = value; }
+        }
+
+#endregion Properties
+
+#region Constructor
+
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="identifier">Identifier for this token bucket</param>
+        /// <param name="parent">Parent bucket if this is a child bucket, or
+        /// null if this is a root bucket</param>
+        /// <param name="maxBurst">Maximum size of the bucket in bytes, or
+        /// zero if this bucket has no maximum capacity</param>
+        /// <param name="dripRate">Rate that the bucket fills, in bytes per
+        /// second. If zero, the bucket always remains full</param>
+        public TokenBucket(TokenBucket parent, float dripRate, float MaxBurst)
+        {
+            m_counter++;
+
+            Parent = parent;
+            RequestedDripRate = dripRate;
+            RequestedBurst = MaxBurst;
+            m_lastDrip = Util.GetTimeStampMS() + 100000.0; // skip first drip
+        }
+
+#endregion Constructor
+
+        /// <summary>
+        /// Compute a modifier for the MaxBurst rate. This is 1.0, meaning
+        /// no modification if the requested bandwidth is less than the
+        /// max burst bandwidth all the way to the root of the throttle
+        /// hierarchy. However, if any of the parents is over-booked, then
+        /// the modifier will be less than 1.
+        /// </summary>
+        protected float DripRateModifier()
+        {
+            float driprate = DripRate;
+            return driprate >= TotalDripRequest ? 1.0f : (driprate / TotalDripRequest);
+        }
+
+        /// <summary>
+        /// </summary>
+        protected float BurstModifier()
+        {
+            // for now... burst rate is always m_quantumsPerBurst (constant)
+            // larger than drip rate so the ratio of burst requests is the
+            // same as the drip ratio
+            return DripRateModifier();
+        }
+
+        /// <summary>
+        /// Register drip rate requested by a child of this throttle. Pass the
+        /// changes up the hierarchy.
+        /// </summary>
+        public void RegisterRequest(TokenBucket child, float request)
+        {
+            lock (m_children)
+            {
+                m_children[child] = request;
+
+                m_totalDripRequest = 0;
+                foreach (KeyValuePair<TokenBucket, float> cref in m_children)
+                    m_totalDripRequest += cref.Value;
+            }
+
+            // Pass the new values up to the parent
+            if (m_parent != null)
+                m_parent.RegisterRequest(this, Math.Min(RequestedDripRate, TotalDripRequest));
+        }
+
+        /// <summary>
+        /// Remove the rate requested by a child of this throttle. Pass the
+        /// changes up the hierarchy.
+        /// </summary>
+        public void UnregisterRequest(TokenBucket child)
+        {
+            lock (m_children)
+            {
+                m_children.Remove(child);
+
+                m_totalDripRequest = 0;
+                foreach (KeyValuePair<TokenBucket, float> cref in m_children)
+                    m_totalDripRequest += cref.Value;
+            }
+
+            // Pass the new values up to the parent
+            if (Parent != null)
+                Parent.RegisterRequest(this,Math.Min(RequestedDripRate, TotalDripRequest));
+        }
+
+        /// <summary>
+        /// Remove a given number of tokens from the bucket
+        /// </summary>
+        /// <param name="amount">Number of tokens to remove from the bucket</param>
+        /// <returns>True if the requested number of tokens were removed from
+        /// the bucket, otherwise false</returns>
+        public bool RemoveTokens(int amount)
+        {
+            // Deposit tokens for this interval
+            Drip();
+
+            // If we have enough tokens then remove them and return
+            if (m_tokenCount - amount >= 0)
+            {
+                // we don't have to remove from the parent, the drip rate is already
+                // reflective of the drip rate limits in the parent
+                m_tokenCount -= amount;
+                return true;
+            }
+
+            return false;
+        }
+
+        public bool CheckTokens(int amount)
+        {
+            return  (m_tokenCount - amount >= 0);
+        }
+
+        public int GetCatBytesCanSend(int timeMS)
+        {
+//            return (int)(m_tokenCount + timeMS * m_dripRate * 1e-3);
+            return (int)(timeMS * DripRate * 1e-3);
+        }
+
+        /// <summary>
+        /// Add tokens to the bucket over time. The number of tokens added each
+        /// call depends on the length of time that has passed since the last
+        /// call to Drip
+        /// </summary>
+        /// <returns>True if tokens were added to the bucket, otherwise false</returns>
+        protected void Drip()
+        {
+            // This should never happen... means we are a leaf node and were created
+            // with no drip rate...
+            if (DripRate == 0)
+            {
+                m_log.WarnFormat("[TOKENBUCKET] something odd is happening and drip rate is 0 for {0}", m_counter);
+                return;
+            }
+
+            double now = Util.GetTimeStampMS();
+            double deltaMS = now - m_lastDrip;
+            m_lastDrip = now;
+
+            if (deltaMS <= 0)
+                return;
+
+            m_tokenCount += (float)deltaMS * DripRate * m_timeScale;
+
+            float burst = Burst;
+            if (m_tokenCount > burst)
+                m_tokenCount = burst;
+        }
+    }
+
+    public class AdaptiveTokenBucket : TokenBucket
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public bool AdaptiveEnabled { get; set; }
+
+        /// <summary>
+        /// The minimum rate for flow control. Minimum drip rate is one
+        /// packet per second.
+        /// </summary>
+
+        protected const float m_minimumFlow = 50000;
+
+        // <summary>
+        // The maximum rate for flow control. Drip rate can never be
+        // greater than this.
+        // </summary>
+
+        public override float MaxDripRate
+        {
+            get { return (m_maxDripRate == 0 ? m_totalDripRequest : m_maxDripRate); }
+            set
+            {
+                m_maxDripRate = (value == 0 ? m_totalDripRequest : Math.Max(value, m_minimumFlow));
+            }
+        }
+
+        private bool m_enabled = false;
+
+        // <summary>
+        // Adjust drip rate in response to network conditions.
+        // </summary>
+        public float AdjustedDripRate
+        {
+            get { return m_dripRate; }
+            set
+            {
+                m_dripRate = OpenSim.Framework.Util.Clamp<float>(value, m_minimumFlow, MaxDripRate);
+
+                if (m_parent != null)
+                    m_parent.RegisterRequest(this, m_dripRate);
+            }
+        }
+
+
+        // <summary>
+        //
+        // </summary>
+        public AdaptiveTokenBucket(TokenBucket parent, float maxDripRate, float maxBurst, bool enabled)
+            : base(parent, maxDripRate, maxBurst)
+        {
+            m_enabled = enabled;
+
+            m_maxDripRate = (maxDripRate == 0 ? m_totalDripRequest : Math.Max(maxDripRate, m_minimumFlow));
+
+            if (enabled)
+                m_dripRate = m_maxDripRate * .5f;
+            else
+                m_dripRate = m_maxDripRate;
+            if (m_parent != null)
+                m_parent.RegisterRequest(this, m_dripRate);
+        }
+
+        /// <summary>
+        /// Reliable packets sent to the client for which we never received an ack adjust the drip rate down.
+        /// <param name="packets">Number of packets that expired without successful delivery</param>
+        /// </summary>
+        public void ExpirePackets(Int32 count)
+        {
+            // m_log.WarnFormat("[ADAPTIVEBUCKET] drop {0} by {1} expired packets",AdjustedDripRate,count);
+            if (m_enabled)
+                AdjustedDripRate = (Int64)(AdjustedDripRate / Math.Pow(2, count));
+        }
+
+        // <summary>
+        //
+        // </summary>
+        public void AcknowledgePackets(Int32 count)
+        {
+            if (m_enabled)
+                AdjustedDripRate = AdjustedDripRate + count;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs b/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs
new file mode 100644
index 0000000..76f4c6f
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs
@@ -0,0 +1,252 @@
+/*
+ * 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.Net;
+using System.Threading;
+using OpenMetaverse;
+
+//using System.Reflection;
+//using log4net;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    /// <summary>
+    /// Special collection that is optimized for tracking unacknowledged packets
+    /// </summary>
+    public sealed class UnackedPacketCollection
+    {
+        /// <summary>
+        /// Holds information about a pending acknowledgement
+        /// </summary>
+        private struct PendingAck
+        {
+            /// <summary>Sequence number of the packet to remove</summary>
+            public uint SequenceNumber;
+            /// <summary>Environment.TickCount value when the remove was queued.
+            /// This is used to update round-trip times for packets</summary>
+            public int RemoveTime;
+            /// <summary>Whether or not this acknowledgement was attached to a
+            /// resent packet. If so, round-trip time will not be calculated</summary>
+            public bool FromResend;
+
+            public PendingAck(uint sequenceNumber, int currentTime, bool fromResend)
+            {
+                SequenceNumber = sequenceNumber;
+                RemoveTime = currentTime;
+                FromResend = fromResend;
+            }
+        }
+
+        //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>Holds the actual unacked packet data, sorted by sequence number</summary>
+        private Dictionary<uint, OutgoingPacket> m_packets = new Dictionary<uint, OutgoingPacket>();
+        /// <summary>Holds packets that need to be added to the unacknowledged list</summary>
+        private LocklessQueue<OutgoingPacket> m_pendingAdds = new LocklessQueue<OutgoingPacket>();
+        /// <summary>Holds information about pending acknowledgements</summary>
+        private LocklessQueue<PendingAck> m_pendingAcknowledgements = new LocklessQueue<PendingAck>();
+        /// <summary>Holds information about pending removals</summary>
+        private LocklessQueue<uint> m_pendingRemoves = new LocklessQueue<uint>();
+
+
+        public void Clear()
+        {
+            m_packets.Clear();
+            m_pendingAdds = null;
+            m_pendingAcknowledgements = null;
+            m_pendingRemoves = null;
+        }
+
+        /// <summary>
+        /// Add an unacked packet to the collection
+        /// </summary>
+        /// <param name="packet">Packet that is awaiting acknowledgement</param>
+        /// <returns>True if the packet was successfully added, false if the
+        /// packet already existed in the collection</returns>
+        /// <remarks>This does not immediately add the ACK to the collection,
+        /// it only queues it so it can be added in a thread-safe way later</remarks>
+        public void Add(OutgoingPacket packet)
+        {
+            m_pendingAdds.Enqueue(packet);
+            Interlocked.Add(ref packet.Client.UnackedBytes, packet.Buffer.DataLength);
+        }
+
+        /// <summary>
+        /// Marks a packet as acknowledged
+        /// This method is used when an acknowledgement is received from the network for a previously
+        /// sent packet. Effects of removal this way are to update unacked byte count, adjust RTT
+        /// and increase throttle to the coresponding client.
+        /// </summary>
+        /// <param name="sequenceNumber">Sequence number of the packet to
+        /// acknowledge</param>
+        /// <param name="currentTime">Current value of Environment.TickCount</param>
+        /// <remarks>This does not immediately acknowledge the packet, it only
+        /// queues the ack so it can be handled in a thread-safe way later</remarks>
+        public void Acknowledge(uint sequenceNumber, int currentTime, bool fromResend)
+        {
+            m_pendingAcknowledgements.Enqueue(new PendingAck(sequenceNumber, currentTime, fromResend));
+        }
+
+        /// <summary>
+        /// Marks a packet as no longer needing acknowledgement without a received acknowledgement.
+        /// This method is called when a packet expires and we no longer need an acknowledgement.
+        /// When some reliable packet types expire, they are handled in a way other than simply
+        /// resending them. The only effect of removal this way is to update unacked byte count.
+        /// </summary>
+        /// <param name="sequenceNumber">Sequence number of the packet to
+        /// acknowledge</param>
+        /// <remarks>The does not immediately remove the packet, it only queues the removal
+        /// so it can be handled in a thread safe way later</remarks>
+        public void Remove(uint sequenceNumber)
+        {
+            m_pendingRemoves.Enqueue(sequenceNumber);
+        }
+
+        /// <summary>
+        /// Returns a list of all of the packets with a TickCount older than
+        /// the specified timeout
+        /// </summary>
+        /// <remarks>
+        /// This function is not thread safe, and cannot be called
+        /// multiple times concurrently
+        /// </remarks>
+        /// <param name="timeoutMS">Number of ticks (milliseconds) before a
+        /// packet is considered expired
+        /// </param>
+        /// <returns>
+        /// A list of all expired packets according to the given
+        /// expiration timeout
+        /// </returns>
+        public List<OutgoingPacket> GetExpiredPackets(int timeoutMS)
+        {
+            ProcessQueues();
+
+            List<OutgoingPacket> expiredPackets = null;
+
+            if (m_packets.Count > 0)
+            {
+                int now = Environment.TickCount & Int32.MaxValue;
+
+                foreach (OutgoingPacket packet in m_packets.Values)
+                {
+                    // TickCount of zero means a packet is in the resend queue
+                    // but hasn't actually been sent over the wire yet
+                    if (packet.TickCount == 0)
+                        continue;
+
+                    if (now - packet.TickCount >= timeoutMS)
+                    {
+                        if (expiredPackets == null)
+                            expiredPackets = new List<OutgoingPacket>();
+
+                        // The TickCount will be set to the current time when the packet
+                        // is actually sent out again
+                        packet.TickCount = 0;
+
+                        // As with other network applications, assume that an expired packet is
+                        // an indication of some network problem, slow transmission
+                        packet.Client.FlowThrottle.ExpirePackets(1);
+
+                        expiredPackets.Add(packet);
+                    }
+                }
+            }
+
+            // if (expiredPackets != null)
+            //     m_log.DebugFormat("[UNACKED PACKET COLLECTION]: Found {0} expired packets on timeout of {1}", expiredPackets.Count, timeoutMS);
+
+            return expiredPackets;
+        }
+
+        private void ProcessQueues()
+        {
+            // Process all the pending adds
+            OutgoingPacket pendingAdd;
+            while (m_pendingAdds.TryDequeue(out pendingAdd))
+                if (pendingAdd != null)
+                    m_packets[pendingAdd.SequenceNumber] = pendingAdd;
+
+            // Process all the pending removes, including updating statistics and round-trip times
+            PendingAck pendingAcknowledgement;
+            while (m_pendingAcknowledgements.TryDequeue(out pendingAcknowledgement))
+            {
+                //m_log.DebugFormat("[UNACKED PACKET COLLECTION]: Processing ack {0}", pendingAcknowledgement.SequenceNumber);
+                OutgoingPacket ackedPacket;
+                if (m_packets.TryGetValue(pendingAcknowledgement.SequenceNumber, out ackedPacket))
+                {
+                    if (ackedPacket != null)
+                    {
+                        m_packets.Remove(pendingAcknowledgement.SequenceNumber);
+
+                        // As with other network applications, assume that an acknowledged packet is an
+                        // indication that the network can handle a little more load, speed up the transmission
+                        ackedPacket.Client.FlowThrottle.AcknowledgePackets(1);
+
+                        // Update stats
+                        Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength);
+
+                        if (!pendingAcknowledgement.FromResend)
+                        {
+                            // Calculate the round-trip time for this packet and its ACK
+                            int rtt = pendingAcknowledgement.RemoveTime - ackedPacket.TickCount;
+                            if (rtt > 0)
+                                ackedPacket.Client.UpdateRoundTrip(rtt);
+                        }
+                    }
+                    else
+                    {
+                        // m_log.WarnFormat("[UNACKED PACKET COLLECTION]: found null packet for sequence number {0} to ack",
+                        //                  pendingAcknowledgement.SequenceNumber);
+                    }
+                }
+                else
+                {
+                    // m_log.WarnFormat("[UNACKED PACKET COLLECTION]: Could not find packet with sequence number {0} to ack",
+                    //                  pendingAcknowledgement.SequenceNumber);
+                }
+            }
+
+            uint pendingRemove;
+            while(m_pendingRemoves.TryDequeue(out pendingRemove))
+            {
+                OutgoingPacket removedPacket;
+                if (m_packets.TryGetValue(pendingRemove, out removedPacket))
+                {
+                    if (removedPacket != null)
+                    {
+                        m_packets.Remove(pendingRemove);
+
+                        // Update stats
+                        Interlocked.Add(ref removedPacket.Client.UnackedBytes, -removedPacket.Buffer.DataLength);
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Properties/AssemblyInfo.cs b/OpenSim/Region/ClientStack/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..e859653
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Region.ClientStack")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSIm")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("02ced54a-a802-4474-9e94-f03a44fde922")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.6.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]