Dump OpenSim 0.9.0.1 into it's own branch.

37 files changed, 6268 insertions, 3776 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/Caps/AgentPreferencesModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/AgentPreferencesModule.cs
index aabdb51..8f65a69 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/AgentPreferencesModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/AgentPreferencesModule.cs
@@ -133,7 +133,7 @@ namespace OpenSim.Region.ClientStack.LindenCaps
             {
                 data = new AgentPrefs(agent);
             }
-                
+
             if (req.ContainsKey("access_prefs"))
             {
                 OSDMap accessPrefs = (OSDMap)req["access_prefs"];  // We could check with ContainsKey...
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/AvatarPickerSearchModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/AvatarPickerSearchModule.cs
index bbadc55..e3c430c 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/AvatarPickerSearchModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/AvatarPickerSearchModule.cs
@@ -53,7 +53,7 @@ namespace OpenSim.Region.ClientStack.Linden
     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;
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
index 774202e..6f5775a 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
@@ -26,11 +26,14 @@
  */
 
 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;
@@ -40,11 +43,11 @@ 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.Framework.Client;
 using OpenSim.Services.Interfaces;
 
 using Caps = OpenSim.Framework.Capabilities.Caps;
@@ -55,14 +58,16 @@ 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);
+        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);
+    public delegate void NewInventoryItem(UUID userID, InventoryItemBase item, uint cost);
 
     public delegate void NewAsset(AssetBase asset);
 
@@ -87,21 +92,12 @@ namespace OpenSim.Region.ClientStack.Linden
             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_requestPath = "0000/";
-        // private static readonly string m_mapLayerPath = "0001/";
-        private static readonly string m_newInventory = "0002/";
-        //private static readonly string m_requestTexture = "0003/";
-        private static readonly string m_notecardUpdatePath = "0004/";
-        private static readonly string m_notecardTaskUpdatePath = "0005/";
-        //        private static readonly string m_fetchInventoryPath = "0006/";
-        private static readonly string m_copyFromNotecardPath = "0007/";
         // private static readonly string m_remoteParcelRequestPath = "0009/";// This is in the LandManagementModule.
-        private static readonly string m_getObjectPhysicsDataPath = "0101/";
-        /* 0102 - 0103 RESERVED */
-        private static readonly string m_UpdateAgentInformationPath = "0500/";
-        
+
         // 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;
@@ -115,12 +111,45 @@ namespace OpenSim.Region.ClientStack.Linden
         private IAssetService m_assetService;
         private bool m_dumpAssetsToFile = false;
         private string m_regionName;
+
         private int m_levelUpload = 0;
 
-        public BunchOfCaps(Scene scene, Caps caps)
+        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)
             {
@@ -135,10 +164,45 @@ namespace OpenSim.Region.ClientStack.Linden
                 {
                     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();
 
@@ -146,6 +210,13 @@ namespace OpenSim.Region.ClientStack.Linden
             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>
@@ -153,33 +224,67 @@ namespace OpenSim.Region.ClientStack.Linden
         /// </summary>
         public void RegisterHandlers()
         {
-            string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+            // this path is also defined elsewhere so keeping it
+            string seedcapsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath +"0000/";
 
-            RegisterRegionServiceHandlers(capsBase);
-            RegisterInventoryServiceHandlers(capsBase);
+            // 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(string capsBase)
+        public void RegisterRegionServiceHandlers()
         {
             try
             {
-                // the root of all evil
-                m_HostCapsObj.RegisterHandler(
-                    "SEED", new RestStreamHandler("POST", capsBase + m_requestPath, SeedCapRequest, "SEED", null));
-
-//                m_log.DebugFormat(
-//                    "[CAPS]: Registered seed capability {0} for {1}", capsBase + m_requestPath, m_HostCapsObj.AgentID);
-
                 //m_capsHandlers["MapLayer"] =
                 //    new LLSDStreamhandler<OSDMapRequest, OSDMapLayerResponse>("POST",
-                //                                                                capsBase + m_mapLayerPath,
-                //                                                                GetMapLayer);
-                IRequestHandler req
-                    = new RestStreamHandler(
-                        "POST", capsBase + m_notecardTaskUpdatePath, ScriptTaskInventory, "UpdateScript", null);
+                //                                                                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)
             {
@@ -187,68 +292,29 @@ namespace OpenSim.Region.ClientStack.Linden
             }
         }
 
-        public void RegisterInventoryServiceHandlers(string capsBase)
+        public void RegisterInventoryServiceHandlers()
         {
             try
             {
-                // I don't think this one works...
-                m_HostCapsObj.RegisterHandler(
-                    "NewFileAgentInventory",
+                m_HostCapsObj.RegisterHandler("NewFileAgentInventory",
                     new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDAssetUploadResponse>(
-                        "POST",
-                        capsBase + m_newInventory,
-                        NewAgentInventoryRequest,
-                        "NewFileAgentInventory",
-                        null));
-
-                IRequestHandler req
-                    = new RestStreamHandler(
-                        "POST", capsBase + m_notecardUpdatePath, NoteCardAgentInventory, "Update*", null);
+                        "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 getObjectPhysicsDataHandler 
-                    = new RestStreamHandler(
-                        "POST", capsBase + m_getObjectPhysicsDataPath, GetObjectPhysicsData, "GetObjectPhysicsData", null);
-                m_HostCapsObj.RegisterHandler("GetObjectPhysicsData", getObjectPhysicsDataHandler);
-
-                IRequestHandler UpdateAgentInformationHandler
-                    = new RestStreamHandler(
-                        "POST", capsBase + m_UpdateAgentInformationPath, UpdateAgentInformation, "UpdateAgentInformation", null);
+                IRequestHandler UpdateAgentInformationHandler = new RestStreamHandler(
+                        "POST",  GetNewCapPath(), UpdateAgentInformation, "UpdateAgentInformation", null);
                 m_HostCapsObj.RegisterHandler("UpdateAgentInformation", UpdateAgentInformationHandler);
 
-                m_HostCapsObj.RegisterHandler(
-                    "CopyInventoryFromNotecard",
-                    new RestStreamHandler(
-                        "POST", capsBase + m_copyFromNotecardPath, CopyInventoryFromNotecard, "CopyInventoryFromNotecard", null));
-             
-                // As of RC 1.22.9 of the Linden client this is
-                // supported
-
-                //m_capsHandlers["WebFetchInventoryDescendents"] =new RestStreamHandler("POST", capsBase + m_fetchInventoryPath, FetchInventoryDescendentsRequest);
-
-                // justincc: I've disabled the CAPS service for now to fix problems with selecting textures, and
-                // subsequent inventory breakage, in the edit object pane (such as mantis 1085).  This requires
-                // enhancements (probably filling out the folder part of the LLSD reply) to our CAPS service,
-                // but when I went on the Linden grid, the
-                // simulators I visited (version 1.21) were, surprisingly, no longer supplying this capability.  Instead,
-                // the 1.19.1.4 client appeared to be happily flowing inventory data over UDP
-                //
-                // This is very probably just a temporary measure - once the CAPS service appears again on the Linden grid
-                // we will be
-                // able to get the data we need to implement the necessary part of the protocol to fix the issue above.
-                //                m_capsHandlers["FetchInventoryDescendents"] =
-                //                    new RestStreamHandler("POST", capsBase + m_fetchInventoryPath, FetchInventoryRequest);
-
-                // m_capsHandlers["FetchInventoryDescendents"] =
-                //     new LLSDStreamhandler<LLSDFetchInventoryDescendents, LLSDInventoryDescendents>("POST",
-                //                                                                                    capsBase + m_fetchInventory,
-                //                                                                                    FetchInventory));
-                // m_capsHandlers["RequestTextureDownload"] = new RestStreamHandler("POST",
-                //                                                                  capsBase + m_requestTexture,
-                //                                                                  RequestTexture);
+                IRequestHandler CopyInventoryFromNotecardHandler = new RestStreamHandler(
+                        "POST",  GetNewCapPath(), CopyInventoryFromNotecard, "CopyInventoryFromNotecard", null);
+                m_HostCapsObj.RegisterHandler("CopyInventoryFromNotecard", CopyInventoryFromNotecardHandler);
+
             }
             catch (Exception e)
             {
@@ -256,6 +322,22 @@ namespace OpenSim.Region.ClientStack.Linden
             }
         }
 
+        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>
@@ -268,8 +350,11 @@ namespace OpenSim.Region.ClientStack.Linden
         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);
+            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))
             {
@@ -314,30 +399,28 @@ namespace OpenSim.Region.ClientStack.Linden
                 LLSDTaskScriptUpdate llsdUpdateRequest = new LLSDTaskScriptUpdate();
                 LLSDHelpers.DeserialiseOSDMap(hash, llsdUpdateRequest);
 
-                string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
-                string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+                string uploaderPath = GetNewCapPath();
 
                 TaskInventoryScriptUpdater uploader =
                     new TaskInventoryScriptUpdater(
                         llsdUpdateRequest.item_id,
                         llsdUpdateRequest.task_id,
                         llsdUpdateRequest.is_script_running,
-                        capsBase + uploaderPath,
+                        uploaderPath,
                         m_HostCapsObj.HttpListener,
                         m_dumpAssetsToFile);
                 uploader.OnUpLoad += TaskScriptUpdated;
 
                 m_HostCapsObj.HttpListener.AddStreamHandler(
                     new BinaryStreamHandler(
-                        "POST", capsBase + uploaderPath, uploader.uploaderCaps, "TaskInventoryScriptUpdater", null));
+                        "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() + capsBase +
-                                     uploaderPath;
+                string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + uploaderPath;
 
                 LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
                 uploadResponse.uploader = uploaderURL;
@@ -400,83 +483,208 @@ namespace OpenSim.Region.ClientStack.Linden
             //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;
-                IClientAPI client = null;
                 m_Scene.TryGetScenePresence(m_HostCapsObj.AgentID, out avatar);
 
                 // check user level
                 if (avatar != null)
                 {
-                    client = avatar.ControllingClient;
-
-                    if (avatar.UserLevel < m_levelUpload)
+                    if (avatar.GodController.UserLevel < m_levelUpload)
                     {
-                        if (client != null)
-                            client.SendAgentAlertMessage("Unable to upload asset. Insufficient permissions.", false);
+                        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 funds
+                // 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")
                     {
-                        if (!mm.UploadCovered(client.AgentId, mm.UploadCharge))
+                        string error;
+                        int modelcost;
+
+
+                        if (!m_ModelCost.MeshModelCost(llsdRequest.asset_resources, baseCost, out modelcost,
+                            meshcostdata, out error, ref warning))
                         {
-                            client.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
+                            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 assetName = llsdRequest.name;
             string assetDes = llsdRequest.description;
-            string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
             UUID newAsset = UUID.Random();
             UUID newInvItem = UUID.Random();
             UUID parentFolder = llsdRequest.folder_id;
-            string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+            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, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
+                        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",
-                    capsBase + uploaderPath,
+                    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() + capsBase +
-                                 uploaderPath;
+            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;
         }
 
@@ -488,8 +696,14 @@ namespace OpenSim.Region.ClientStack.Linden
         /// <param name="data"></param>
         public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
                                           UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
-                                          string assetType)
+                                          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);
@@ -497,6 +711,34 @@ namespace OpenSim.Region.ClientStack.Linden
             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;
@@ -511,6 +753,12 @@ namespace OpenSim.Region.ClientStack.Linden
                 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;
@@ -526,191 +774,290 @@ namespace OpenSim.Region.ClientStack.Linden
             }
             else if (inventoryType == "object")
             {
-                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);
-                OSDArray instance_list = (OSDArray)request["instance_list"];
-                OSDArray mesh_list = (OSDArray)request["mesh_list"];
-                OSDArray texture_list = (OSDArray)request["texture_list"];
-                SceneObjectGroup grp = null;
+                if (assetType == "mesh") // this code for now is for mesh models uploads only
+                {
+                    inType = (sbyte)InventoryType.Object;
+                    assType = (sbyte)AssetType.Object;
 
-                InventoryFolderBase textureUploadFolder = null;
+                    List<Vector3> positions = new List<Vector3>();
+                    List<Quaternion> rotations = new List<Quaternion>();
+                    OSDMap request = (OSDMap)OSDParser.DeserializeLLSDXml(data);
 
-                List<InventoryFolderBase> foldersToUpdate = new List<InventoryFolderBase>();
-                List<InventoryItemBase> itemsToUpdate = new List<InventoryItemBase>();
-                IClientInventory clientInv = null;
-                
-                if (texture_list.Count > 0)
-                {
-                    ScenePresence avatar = null;
-                    m_Scene.TryGetScenePresence(m_HostCapsObj.AgentID, out avatar);
+                    // 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;
 
-                    if (avatar != null)
+                    while (mismatchError)
                     {
-                        IClientCore core = (IClientCore)avatar.ControllingClient;
+                        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;
 
-                        if (core.TryGet<IClientInventory>(out clientInv))
+                    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)
                         {
-                            var systemTextureFolder = m_Scene.InventoryService.GetFolderForType(m_HostCapsObj.AgentID, FolderType.Texture);
-                            textureUploadFolder = new InventoryFolderBase(UUID.Random(), assetName, m_HostCapsObj.AgentID, (short)FolderType.None, systemTextureFolder.ID, 1);
-                            if (m_Scene.InventoryService.AddFolder(textureUploadFolder))
-                            {
-                                foldersToUpdate.Add(textureUploadFolder);
+                            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;
+                        }
+                    }
 
-                                m_log.DebugFormat(
-                                    "[BUNCH OF CAPS]: Created new folder '{0}' ({1}) for textures uploaded with mesh object {2}", 
-                                    textureUploadFolder.Name, textureUploadFolder.ID, assetName);
-                            }
-                            else
+                    // 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"))
                             {
-                                textureUploadFolder = null;
+                                OSDMap skeleton = (OSDMap)mosd["skeleton"];
+                                int sksize = skeleton["size"].AsInteger();
+                                if (sksize > 0)
+                                    curAvSkeleton = true;
                             }
                         }
-                    }
-                }
 
-                List<UUID> textures = new List<UUID>();
-                for (int i = 0; i < texture_list.Count; i++)
-                {
-                    AssetBase textureAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Texture, "");
-                    textureAsset.Data = texture_list[i].AsBinary();
-                    m_assetService.Store(textureAsset);
-                    textures.Add(textureAsset.FullID);
+                        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;
+                        }
+                    }
 
-                    if (textureUploadFolder != null)
+                    int skipedMeshs = 0;
+                    // build prims from instances
+                    for (int i = 0; i < instance_list.Count; i++)
                     {
-                        InventoryItemBase textureItem = new InventoryItemBase();
-                        textureItem.Owner = m_HostCapsObj.AgentID;
-                        textureItem.CreatorId = m_HostCapsObj.AgentID.ToString();
-                        textureItem.CreatorData = String.Empty;
-                        textureItem.ID = UUID.Random();
-                        textureItem.AssetID = textureAsset.FullID;
-                        textureItem.Description = assetDescription;
-                        textureItem.Name = assetName + " - Texture " + (i + 1).ToString();
-                        textureItem.AssetType = (int)AssetType.Texture;
-                        textureItem.InvType = (int)InventoryType.Texture;
-                        textureItem.Folder = textureUploadFolder.ID;
-                        textureItem.CurrentPermissions
-                            = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer | PermissionMask.Export);
-                        textureItem.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
-                        textureItem.EveryOnePermissions = 0;
-                        textureItem.NextPermissions = (uint)PermissionMask.All;
-                        textureItem.CreationDate = Util.UnixTimeSinceEpoch();
-                        m_Scene.InventoryService.AddItem(textureItem);
-                        itemsToUpdate.Add(textureItem);
-
-                        m_log.DebugFormat(
-                            "[BUNCH OF CAPS]: Created new inventory item '{0}' ({1}) for texture uploaded with mesh object {2}", 
-                            textureItem.Name, textureItem.ID, assetName);
-                    }
-                }
+                        OSDMap inner_instance_list = (OSDMap)instance_list[i];
 
-                if (clientInv != null && (foldersToUpdate.Count > 0 || itemsToUpdate.Count > 0))
-                {
-                    clientInv.SendBulkUpdateInventory(foldersToUpdate.ToArray(), itemsToUpdate.ToArray());
-                }
+                        // skip prims that are 2 small
+                        Vector3 scale = inner_instance_list["scale"].AsVector3();
 
-                for (int i = 0; i < mesh_list.Count; i++)
-                {
-                    PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+                        if (scale.X < m_PrimScaleMin || scale.Y < m_PrimScaleMin || scale.Z < m_PrimScaleMin)
+                        {
+                            skipedMeshs++;
+                            continue;
+                        }
 
-                    Primitive.TextureEntry textureEntry
-                        = new Primitive.TextureEntry(Primitive.TextureEntry.WHITE_TEXTURE);
-                    OSDMap inner_instance_list = (OSDMap)instance_list[i];
+                        OSDArray face_list = (OSDArray)inner_instance_list["face_list"];
 
-                    OSDArray face_list = (OSDArray)inner_instance_list["face_list"];
-                    for (uint face = 0; face < face_list.Count; face++)
-                    {
-                        OSDMap faceMap = (OSDMap)face_list[(int)face];
-                        Primitive.TextureEntryFace f = pbs.Textures.CreateFace(face);
-                        if(faceMap.ContainsKey("fullbright"))
-                            f.Fullbright = faceMap["fullbright"].AsBoolean();
-                        if (faceMap.ContainsKey ("diffuse_color"))
-                            f.RGBA = faceMap["diffuse_color"].AsColor4();
+                        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);
 
-                        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();
+                        for (uint face = 0; face < face_list.Count; face++)
+                        {
+                            OSDMap faceMap = (OSDMap)face_list[(int)face];
 
-                        if(imagerot != 0)
-                            f.Rotation = imagerot;
+                            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();
 
-                        if(offsets != 0)
-                            f.OffsetU = offsets;
+                            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 (offsett != 0)
-                            f.OffsetV = offsett;
+                            if (imagerot != 0)
+                                f.Rotation = imagerot;
 
-                        if (scales != 0)
-                            f.RepeatU = scales;
+                            if (offsets != 0)
+                                f.OffsetU = offsets;
 
-                        if (scalet != 0)
-                            f.RepeatV = scalet;
+                            if (offsett != 0)
+                                f.OffsetV = offsett;
 
-                        if (textures.Count > textureNum)
-                            f.TextureID = textures[textureNum];
+                            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
-                            f.TextureID = Primitive.TextureEntry.WHITE_TEXTURE;
+                            prim.Name = assetName + "#" + i.ToString();
 
-                        textureEntry.FaceTextures[face] = f;
-                    }
+                        prim.EveryoneMask = 0;
+                        prim.GroupMask = 0;
 
-                    pbs.TextureEntry = textureEntry.GetBytes();
-
-                    AssetBase meshAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Mesh, "");
-                    meshAsset.Data = mesh_list[i].AsBinary();
-                    m_assetService.Store(meshAsset);
-
-                    pbs.SculptEntry = true;
-                    pbs.SculptTexture = meshAsset.FullID;
-                    pbs.SculptType = (byte)SculptType.Mesh;
-                    pbs.SculptData = meshAsset.Data;
-
-                    Vector3 position = inner_instance_list["position"].AsVector3();
-                    Vector3 scale = inner_instance_list["scale"].AsVector3();
-                    Quaternion rotation = inner_instance_list["rotation"].AsQuaternion();
-
-// no longer used - begin ------------------------
-//                    int physicsShapeType = inner_instance_list["physics_shape_type"].AsInteger();
-//                    int material = inner_instance_list["material"].AsInteger();
-//                    int mesh = inner_instance_list["mesh"].AsInteger();
-
-//                    OSDMap permissions = (OSDMap)inner_instance_list["permissions"];
-//                    int base_mask = permissions["base_mask"].AsInteger();
-//                    int everyone_mask = permissions["everyone_mask"].AsInteger();
-//                    UUID creator_id = permissions["creator_id"].AsUUID();
-//                    UUID group_id = permissions["group_id"].AsUUID();
-//                    int group_mask = permissions["group_mask"].AsInteger();
-//                    bool is_owner_group = permissions["is_owner_group"].AsBoolean();
-//                    UUID last_owner_id = permissions["last_owner_id"].AsUUID();
-//                    int next_owner_mask = permissions["next_owner_mask"].AsInteger();
-//                    UUID owner_id = permissions["owner_id"].AsUUID();
-//                    int owner_mask = permissions["owner_mask"].AsInteger();
-// no longer used - end ------------------------
-
-                      UUID owner_id = m_HostCapsObj.AgentID;
-
-                    SceneObjectPart prim
-                        = new SceneObjectPart(owner_id, pbs, position, Quaternion.Identity, Vector3.Zero);
-
-                    prim.Scale = scale;
-                    //prim.OffsetPosition = position;
-                    rotations.Add(rotation);
-                    positions.Add(position);
-                    prim.UUID = UUID.Random();
-                    prim.CreatorID = owner_id;
-                    prim.OwnerID = owner_id;
-                    prim.GroupID = UUID.Zero;
-                    prim.LastOwnerID = prim.OwnerID;
-                    prim.CreationDate = Util.UnixTimeSinceEpoch();
-                    prim.Name = assetName;
-                    prim.Description = "";
+                        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;
@@ -718,52 +1065,65 @@ namespace OpenSim.Region.ClientStack.Linden
 //                    prim.NextOwnerMask = (uint)next_owner_mask;
 //                    prim.OwnerMask = (uint)owner_mask;
 
-                    if (grp == null)
-                        grp = new SceneObjectGroup(prim);
-                    else
-                        grp.AddPart(prim);
-                }
+                        if (grp == null)
+                        {
+                            grp = new SceneObjectGroup(prim);
+                            grp.LastOwnerID = creatorID;
+                            grp.RezzerID = creatorID;
+                        }
+                        else
+                            grp.AddPart(prim);
+                    }
 
-                Vector3 rootPos = positions[0];
+                    Vector3 rootPos = positions[0];
 
-                if (grp.Parts.Length > 1)
-                {
-                    // Fix first link number
-                    grp.RootPart.LinkNum++;
+                    if (grp.Parts.Length > 1)
+                    {
+                        // Fix first link number
+                        grp.RootPart.LinkNum++;
 
-                    Quaternion rootRotConj = Quaternion.Conjugate(rotations[0]);
-                    Quaternion tmprot;
-                    Vector3 offset;
+                        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;
+                        // fix children rotations and positions
+                        for (int i = 1; i < rotations.Count; i++)
+                        {
+                            tmprot = rotations[i];
+                            tmprot = rootRotConj * tmprot;
 
-                        grp.Parts[i].RotationOffset = tmprot;
+                            grp.Parts[i].RotationOffset = tmprot;
 
-                        offset = positions[i] - rootPos;
+                            offset = positions[i] - rootPos;
+
+                            offset *= rootRotConj;
+                            grp.Parts[i].OffsetPosition = offset;
+                        }
 
-                        offset *= rootRotConj;
-                        grp.Parts[i].OffsetPosition = offset;
+                        grp.AbsolutePosition = rootPos;
+                        grp.UpdateGroupRotationR(rotations[0]);
+                    }
+                    else
+                    {
+                        grp.AbsolutePosition = rootPos;
+                        grp.UpdateGroupRotationR(rotations[0]);
                     }
 
-                    grp.AbsolutePosition = rootPos;
-                    grp.UpdateGroupRotationR(rotations[0]);
+                    data = ASCIIEncoding.ASCII.GetBytes(SceneObjectSerializer.ToOriginalXmlFormat(grp));
                 }
-                else
+
+                else // not a mesh model
                 {
-                    grp.AbsolutePosition = rootPos;
-                    grp.UpdateGroupRotationR(rotations[0]);
+                    m_log.ErrorFormat("[CAPS Asset Upload] got unsuported assetType for object upload");
+                    return;
                 }
-
-                data = ASCIIEncoding.ASCII.GetBytes(SceneObjectSerializer.ToOriginalXmlFormat(grp));
             }
 
             AssetBase asset;
-            asset = new AssetBase(assetID, assetName, assType, m_HostCapsObj.AgentID.ToString());
+            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)
@@ -771,11 +1131,17 @@ namespace OpenSim.Region.ClientStack.Linden
 
             InventoryItemBase item = new InventoryItemBase();
             item.Owner = m_HostCapsObj.AgentID;
-            item.CreatorId = m_HostCapsObj.AgentID.ToString();
+            item.CreatorId = creatorIDstr;
             item.CreatorData = String.Empty;
             item.ID = inventoryItem;
             item.AssetID = asset.FullID;
-            item.Description = assetDescription;
+            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;
@@ -783,18 +1149,69 @@ namespace OpenSim.Region.ClientStack.Linden
 
             // 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.
-            item.CurrentPermissions
-                = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer | PermissionMask.Export);
 
-            item.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
-            item.EveryOnePermissions = 0;
-            item.NextPermissions = (uint)PermissionMask.All;
+            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)
             {
-                AddNewInventoryItem(m_HostCapsObj.AgentID, item);
+                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>
@@ -857,24 +1274,22 @@ namespace OpenSim.Region.ClientStack.Linden
             LLSDItemUpdate llsdRequest = new LLSDItemUpdate();
             LLSDHelpers.DeserialiseOSDMap(hash, llsdRequest);
 
-            string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
-            string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+            string uploaderPath = GetNewCapPath();
 
             ItemUpdater uploader =
-                new ItemUpdater(llsdRequest.item_id, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
+                new ItemUpdater(llsdRequest.item_id, uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
             uploader.OnUpLoad += ItemUpdated;
 
             m_HostCapsObj.HttpListener.AddStreamHandler(
                 new BinaryStreamHandler(
-                    "POST", capsBase + uploaderPath, uploader.uploaderCaps, "NoteCardAgentInventory", null));
+                    "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() + capsBase +
-                                 uploaderPath;
+            string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + uploaderPath;
 
             LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
             uploadResponse.uploader = uploaderURL;
@@ -930,29 +1345,22 @@ namespace OpenSim.Region.ClientStack.Linden
                 IClientAPI client = null;
 
                 m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);
-                item = m_Scene.InventoryService.GetItem(new InventoryItemBase(itemID));
+                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 (client != null)
+                    if (copyItem != null && client != null)
                     {
-                        if (copyItem != null)
-                        {
-                            m_log.InfoFormat("[CAPS]: CopyInventoryFromNotecard, ItemID:{0}, FolderID:{1}", copyItem.ID, copyItem.Folder);
-                            client.SendBulkUpdateInventory(copyItem);
-                        }
-                        else
-                        {
-                            client.SendAgentAlertMessage(message, false);
-                        }
+                        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.SendAgentAlertMessage("Failed to retrieve item", false);
+                        client.SendAlertMessage("Failed to retrieve item");
                 }
             }
             catch (Exception e)
@@ -995,26 +1403,483 @@ namespace OpenSim.Region.ClientStack.Linden
             return response;
         }
 
-        public string UpdateAgentInformation(string request, string path,
+        public string GetObjectCost(string request, string path,
                 string param, IOSHttpRequest httpRequest,
                 IOSHttpResponse httpResponse)
         {
             OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
-            OSDMap accessPrefs = (OSDMap)req["access_prefs"];
-            string desiredMaturity = accessPrefs["max"];
+            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 respAccessPrefs = new OSDMap();
-            respAccessPrefs["max"] = desiredMaturity;   // echoing the maturity back means success
-            resp["access_prefs"] = respAccessPrefs;
+
+            OSDMap accessPrefs = new OSDMap();
+            accessPrefs["max"] = "A";
+
+            resp["access_prefs"] = accessPrefs;
 
             string response = OSDParser.SerializeLLSDXmlString(resp);
-            return response; 
+            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;
 
@@ -1029,10 +1894,26 @@ namespace OpenSim.Region.ClientStack.Linden
 
         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)
+                                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;
@@ -1044,6 +1925,22 @@ namespace OpenSim.Region.ClientStack.Linden
             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>
@@ -1058,12 +1955,14 @@ namespace OpenSim.Region.ClientStack.Linden
             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
@@ -1080,12 +1979,55 @@ namespace OpenSim.Region.ClientStack.Linden
             handlerUpLoad = OnUpLoad;
             if (handlerUpLoad != null)
             {
-                handlerUpLoad(m_assetName, m_assetDes, newAssetID, inv, parentFolder, data, m_invType, m_assetType);
+                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)
         //{
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs
index c241075..683c3d5 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs
@@ -63,7 +63,7 @@ namespace OpenSim.Region.ClientStack.Linden
         {
         }
 
-        public void Close() { } 
+        public void Close() { }
 
         public void AddRegion(Scene scene)
         {
@@ -80,11 +80,11 @@ namespace OpenSim.Region.ClientStack.Linden
         }
 
         public void PostInitialise() { }
-        #endregion 
+        #endregion
 
         private void OnRegisterCaps(UUID agentID, Caps caps)
         {
-            new BunchOfCaps(m_Scene, 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
index 9b9f6a7..7c9a1c4 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
@@ -74,13 +74,12 @@ namespace OpenSim.Region.ClientStack.Linden
         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_QueueUUIDAvatarMapping = new Dictionary<UUID, UUID>();
         private Dictionary<UUID, UUID> m_AvatarQueueUUIDMapping = new Dictionary<UUID, UUID>();
-            
+
         #region INonSharedRegionModule methods
         public virtual void Initialise(IConfigSource config)
         {
@@ -171,7 +170,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 foreach (KeyValuePair<UUID, Queue<OSD>> kvp in queues)
                 {
                     MainConsole.Instance.OutputFormat(
-                        "For agent {0} there are {1} messages queued for send.", 
+                        "For agent {0} there are {1} messages queued for send.",
                         kvp.Key, kvp.Value.Count);
                 }
             }
@@ -190,7 +189,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 {
                     if (DebugLevel > 0)
                         m_log.DebugFormat(
-                            "[EVENTQUEUE]: Adding new queue for agent {0} in region {1}", 
+                            "[EVENTQUEUE]: Adding new queue for agent {0} in region {1}",
                             agentId, m_scene.RegionInfo.RegionName);
 
                     queues[agentId] = new Queue<OSD>();
@@ -201,6 +200,7 @@ namespace OpenSim.Region.ClientStack.Linden
         }
 
         /// <summary>
+
         /// May return a null queue
         /// </summary>
         /// <param name="agentId"></param>
@@ -231,26 +231,20 @@ namespace OpenSim.Region.ClientStack.Linden
                     lock (queue)
                         queue.Enqueue(ev);
                 }
-                else if (DebugLevel > 0)
+                else
                 {
-                    ScenePresence sp = m_scene.GetScenePresence(avatarID);
-
-                    // This assumes that an NPC should never have a queue.
-                    if (sp != null && sp.PresenceType != PresenceType.Npc)
-                    {
                         OSDMap evMap = (OSDMap)ev;
                         m_log.WarnFormat(
-                            "[EVENTQUEUE]: (Enqueue) No queue found for agent {0} {1} when placing message {2} in region {3}", 
-                            sp.Name, sp.UUID, evMap["message"], m_scene.Name);
-                    }
+                            "[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;
         }
 
@@ -263,28 +257,13 @@ namespace OpenSim.Region.ClientStack.Linden
             lock (queues)
                 queues.Remove(agentID);
 
-            List<UUID> removeitems = new List<UUID>();
             lock (m_AvatarQueueUUIDMapping)
                 m_AvatarQueueUUIDMapping.Remove(agentID);
 
-            UUID searchval = UUID.Zero;
-
-            removeitems.Clear();
-            
-            lock (m_QueueUUIDAvatarMapping)
+            lock (m_ids)
             {
-                foreach (UUID ky in m_QueueUUIDAvatarMapping.Keys)
-                {
-                    searchval = m_QueueUUIDAvatarMapping[ky];
-
-                    if (searchval == agentID)
-                    {
-                        removeitems.Add(ky);
-                    }
-                }
-
-                foreach (UUID ky in removeitems)
-                    m_QueueUUIDAvatarMapping.Remove(ky);
+                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);
@@ -309,55 +288,95 @@ namespace OpenSim.Region.ClientStack.Linden
                     "[EVENTQUEUE]: OnRegisterCaps: agentID {0} caps {1} region {2}",
                     agentID, caps, m_scene.RegionInfo.RegionName);
 
-            // Let's instantiate a Queue for this agent right now
-            TryGetQueue(agentID);
-
             UUID eventQueueGetUUID;
+            Queue<OSD> queue;
+            Random rnd = new Random(Environment.TickCount);
+            int nrnd = rnd.Next(30000000);
+            if (nrnd < 0)
+                nrnd = -nrnd;
 
-            lock (m_AvatarQueueUUIDMapping)
+            lock (queues)
             {
-                // Reuse open queues.  The client does!
-                if (m_AvatarQueueUUIDMapping.ContainsKey(agentID))
+                if (queues.ContainsKey(agentID))
+                    queue = queues[agentID];
+                else
+                    queue = null;
+
+                if (queue == null)
                 {
-                    //m_log.DebugFormat("[EVENTQUEUE]: Found Existing UUID!");
-                    eventQueueGetUUID = m_AvatarQueueUUIDMapping[agentID];
+                    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
                 {
-                    eventQueueGetUUID = UUID.Random();
-                    //m_log.DebugFormat("[EVENTQUEUE]: Using random UUID!");
+                    // 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];
+                    }
                 }
             }
 
-            lock (m_QueueUUIDAvatarMapping)
-            {
-                if (!m_QueueUUIDAvatarMapping.ContainsKey(eventQueueGetUUID))
-                    m_QueueUUIDAvatarMapping.Add(eventQueueGetUUID, agentID);
-            }
-
-            lock (m_AvatarQueueUUIDMapping)
-            {
-                if (!m_AvatarQueueUUIDMapping.ContainsKey(agentID))
-                    m_AvatarQueueUUIDMapping.Add(agentID, eventQueueGetUUID);
-            }
-
             caps.RegisterPollHandler(
                 "EventQueueGet",
                 new PollServiceEventArgs(null, GenerateEqgCapPath(eventQueueGetUUID), HasEvents, GetEvents, NoEvents, agentID, SERVER_EQ_TIME_NO_EVENTS));
-
-            Random rnd = new Random(Environment.TickCount);
-            lock (m_ids)
-            {
-                if (!m_ids.ContainsKey(agentID))
-                    m_ids.Add(agentID, rnd.Next(30000000));
-            }
         }
 
         public bool HasEvents(UUID requestID, UUID agentID)
         {
-            // Don't use this, because of race conditions at agent closing time
-            //Queue<OSD> queue = TryGetQueue(agentID);
-
             Queue<OSD> queue = GetQueue(agentID);
             if (queue != null)
                 lock (queue)
@@ -366,7 +385,8 @@ namespace OpenSim.Region.ClientStack.Linden
                     return queue.Count > 0;
                 }
 
-            return false;
+            //m_log.WarnFormat("POLLED FOR EVENTS BY {0} unknown agent", agentID);
+            return true;
         }
 
         /// <summary>
@@ -383,6 +403,10 @@ namespace OpenSim.Region.ClientStack.Linden
                     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)
         {
@@ -395,55 +419,65 @@ namespace OpenSim.Region.ClientStack.Linden
                 return NoEvents(requestID, pAgentId);
             }
 
-            OSD element;
+            OSD element = null;;
+            OSDArray array = new OSDArray();
+            int thisID = 0;
+            bool negativeID = false;
+
             lock (queue)
             {
                 if (queue.Count == 0)
                     return NoEvents(requestID, pAgentId);
-                element = queue.Dequeue(); // 15s timeout
-            }
-
-            int thisID = 0;
-            lock (m_ids)
-                thisID = m_ids[pAgentId];
 
-            OSDArray array = new OSDArray();
-            if (element == null) // didn't have an event in 15s
-            {
-                // Send it a fake event to keep the client polling!   It doesn't like 502s like the proxys say!
-                array.Add(EventQueueHelper.KeepAliveEvent());
-                //m_log.DebugFormat("[EVENTQUEUE]: adding fake event for {0} in region {1}", pAgentId, m_scene.RegionInfo.RegionName);
-            }
-            else
-            {
-                if (DebugLevel > 0)
-                    LogOutboundDebugMessage(element, pAgentId);
+                lock (m_ids)
+                    thisID = m_ids[pAgentId];
 
-                array.Add(element);
+                if (thisID < 0)
+                {
+                    negativeID = true;
+                    thisID = -thisID;
+                }
 
-                lock (queue)
+                while (queue.Count > 0)
                 {
-                    while (queue.Count > 0)
-                    {
-                        element = queue.Dequeue();
+                    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++;
+                }
+            }
 
-                        if (DebugLevel > 0)
-                            LogOutboundDebugMessage(element, pAgentId);
+            OSDMap events = null;
 
-                        array.Add(element);
-                        thisID++;
-                    }
-                }
+            if (array.Count > 0)
+            {
+                events = new OSDMap();
+                events.Add("events", array);
+                events.Add("id", new OSDInteger(thisID));
             }
 
-            OSDMap events = new OSDMap();
-            events.Add("events", array);
+            if (negativeID && element == null)
+            {
+                Random rnd = new Random(Environment.TickCount);
+                thisID = rnd.Next(30000000);
+                if (thisID < 0)
+                    thisID = -thisID;
+            }
 
-            events.Add("id", new OSDInteger(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";
@@ -461,266 +495,18 @@ namespace OpenSim.Region.ClientStack.Linden
             responsedata["content_type"] = "text/plain";
             responsedata["keepalive"] = false;
             responsedata["reusecontext"] = false;
-            responsedata["str_response_string"] = "Upstream error: ";
-            responsedata["error_status_text"] = "Upstream error:";
+            responsedata["str_response_string"] = "<llsd></llsd>";
+            responsedata["error_status_text"] = "<llsd></llsd>";
             responsedata["http_protocol_version"] = "HTTP/1.0";
             return responsedata;
         }
-
-//        public Hashtable ProcessQueue(Hashtable request, UUID agentID, Caps caps)
-//        {
-//            // TODO: this has to be redone to not busy-wait (and block the thread),
-//            // TODO: as soon as we have a non-blocking way to handle HTTP-requests.
-//
-////            if (m_log.IsDebugEnabled)
-////            {
-////                String debug = "[EVENTQUEUE]: Got request for agent {0} in region {1} from thread {2}: [  ";
-////                foreach (object key in request.Keys)
-////                {
-////                    debug += key.ToString() + "=" + request[key].ToString() + "  ";
-////                }
-////                m_log.DebugFormat(debug + "  ]", agentID, m_scene.RegionInfo.RegionName, System.Threading.Thread.CurrentThread.Name);
-////            }
-//
-//            Queue<OSD> queue = TryGetQueue(agentID);
-//            OSD element;
-//
-//            lock (queue)
-//                element = queue.Dequeue(); // 15s timeout
-//
-//            Hashtable responsedata = new Hashtable();
-//
-//            int thisID = 0;
-//            lock (m_ids)
-//                thisID = m_ids[agentID];
-//
-//            if (element == null)
-//            {
-//                //m_log.ErrorFormat("[EVENTQUEUE]: Nothing to process in " + m_scene.RegionInfo.RegionName);
-//                if (thisID == -1) // close-request
-//                {
-//                    m_log.ErrorFormat("[EVENTQUEUE]: 404 in " + m_scene.RegionInfo.RegionName);
-//                    responsedata["int_response_code"] = 404; //501; //410; //404;
-//                    responsedata["content_type"] = "text/plain";
-//                    responsedata["keepalive"] = false;
-//                    responsedata["str_response_string"] = "Closed EQG";
-//                    return responsedata;
-//                }
-//                responsedata["int_response_code"] = 502;
-//                responsedata["content_type"] = "text/plain";
-//                responsedata["keepalive"] = false;
-//                responsedata["str_response_string"] = "Upstream error: ";
-//                responsedata["error_status_text"] = "Upstream error:";
-//                responsedata["http_protocol_version"] = "HTTP/1.0";
-//                return responsedata;
-//            }
-//
-//            OSDArray array = new OSDArray();
-//            if (element == null) // didn't have an event in 15s
-//            {
-//                // Send it a fake event to keep the client polling!   It doesn't like 502s like the proxys say!
-//                array.Add(EventQueueHelper.KeepAliveEvent());
-//                //m_log.DebugFormat("[EVENTQUEUE]: adding fake event for {0} in region {1}", agentID, m_scene.RegionInfo.RegionName);
-//            }
-//            else
-//            {
-//                array.Add(element);
-//
-//                if (element is OSDMap)
-//                {
-//                    OSDMap ev = (OSDMap)element;
-//                    m_log.DebugFormat(
-//                        "[EVENT QUEUE GET MODULE]: Eq OUT {0} to {1}",
-//                        ev["message"], m_scene.GetScenePresence(agentID).Name);
-//                }
-//
-//                lock (queue)
-//                {
-//                    while (queue.Count > 0)
-//                    {
-//                        element = queue.Dequeue();
-//
-//                        if (element is OSDMap)
-//                        {
-//                            OSDMap ev = (OSDMap)element;
-//                            m_log.DebugFormat(
-//                                "[EVENT QUEUE GET MODULE]: Eq OUT {0} to {1}",
-//                                ev["message"], m_scene.GetScenePresence(agentID).Name);
-//                        }
-//
-//                        array.Add(element);
-//                        thisID++;
-//                    }
-//                }
-//            }
-//
-//            OSDMap events = new OSDMap();
-//            events.Add("events", array);
-//
-//            events.Add("id", new OSDInteger(thisID));
-//            lock (m_ids)
-//            {
-//                m_ids[agentID] = thisID + 1;
-//            }
-//
-//            responsedata["int_response_code"] = 200;
-//            responsedata["content_type"] = "application/xml";
-//            responsedata["keepalive"] = false;
-//            responsedata["str_response_string"] = OSDParser.SerializeLLSDXmlString(events);
-//
-//            m_log.DebugFormat("[EVENTQUEUE]: sending response for {0} in region {1}: {2}", agentID, m_scene.RegionInfo.RegionName, responsedata["str_response_string"]);
-//
-//            return responsedata;
-//        }
-
-//        public Hashtable EventQueuePath2(Hashtable request)
-//        {
-//            string capuuid = (string)request["uri"]; //path.Replace("/CAPS/EQG/","");
-//            // pull off the last "/" in the path.
-//            Hashtable responsedata = new Hashtable();
-//            capuuid = capuuid.Substring(0, capuuid.Length - 1);
-//            capuuid = capuuid.Replace("/CAPS/EQG/", "");
-//            UUID AvatarID = UUID.Zero;
-//            UUID capUUID = UUID.Zero;
-//
-//            // parse the path and search for the avatar with it registered
-//            if (UUID.TryParse(capuuid, out capUUID))
-//            {
-//                lock (m_QueueUUIDAvatarMapping)
-//                {
-//                    if (m_QueueUUIDAvatarMapping.ContainsKey(capUUID))
-//                    {
-//                        AvatarID = m_QueueUUIDAvatarMapping[capUUID];
-//                    }
-//                }
-//                
-//                if (AvatarID != UUID.Zero)
-//                {
-//                    return ProcessQueue(request, AvatarID, m_scene.CapsModule.GetCapsForUser(AvatarID));
-//                }
-//                else
-//                {
-//                    responsedata["int_response_code"] = 404;
-//                    responsedata["content_type"] = "text/plain";
-//                    responsedata["keepalive"] = false;
-//                    responsedata["str_response_string"] = "Not Found";
-//                    responsedata["error_status_text"] = "Not Found";
-//                    responsedata["http_protocol_version"] = "HTTP/1.0";
-//                    return responsedata;
-//                    // return 404
-//                }
-//            }
-//            else
-//            {
-//                responsedata["int_response_code"] = 404;
-//                responsedata["content_type"] = "text/plain";
-//                responsedata["keepalive"] = false;
-//                responsedata["str_response_string"] = "Not Found";
-//                responsedata["error_status_text"] = "Not Found";
-//                responsedata["http_protocol_version"] = "HTTP/1.0";
-//                return responsedata;
-//                // return 404
-//            }
-//        }
-
-        public OSD EventQueueFallBack(string path, OSD request, string endpoint)
-        {
-            // This is a fallback element to keep the client from loosing EventQueueGet
-            // Why does CAPS fail sometimes!?
-            m_log.Warn("[EVENTQUEUE]: In the Fallback handler!   We lost the Queue in the rest handler!");
-            string capuuid = path.Replace("/CAPS/EQG/","");
-            capuuid = capuuid.Substring(0, capuuid.Length - 1);
-
-//            UUID AvatarID = UUID.Zero;
-            UUID capUUID = UUID.Zero;
-            if (UUID.TryParse(capuuid, out capUUID))
-            {
-/* Don't remove this yet code cleaners!
- * Still testing this!
- * 
-                lock (m_QueueUUIDAvatarMapping)
-                {
-                    if (m_QueueUUIDAvatarMapping.ContainsKey(capUUID))
-                    {
-                        AvatarID = m_QueueUUIDAvatarMapping[capUUID];
-                    }
-                }
-                
-                 
-                if (AvatarID != UUID.Zero)
-                {
-                    // Repair the CAP!
-                    //OpenSim.Framework.Capabilities.Caps caps = m_scene.GetCapsHandlerForUser(AvatarID);
-                    //string capsBase = "/CAPS/EQG/";
-                    //caps.RegisterHandler("EventQueueGet",
-                                //new RestHTTPHandler("POST", capsBase + capUUID.ToString() + "/",
-                                                      //delegate(Hashtable m_dhttpMethod)
-                                                      //{
-                                                      //    return ProcessQueue(m_dhttpMethod, AvatarID, caps);
-                                                      //}));
-                    // start new ID sequence.
-                    Random rnd = new Random(System.Environment.TickCount);
-                    lock (m_ids)
-                    {
-                        if (!m_ids.ContainsKey(AvatarID))
-                            m_ids.Add(AvatarID, rnd.Next(30000000));
-                    }
-
-
-                    int thisID = 0;
-                    lock (m_ids)
-                        thisID = m_ids[AvatarID];
-
-                    BlockingLLSDQueue queue = GetQueue(AvatarID);
-                    OSDArray array = new OSDArray();
-                    LLSD element = queue.Dequeue(15000); // 15s timeout
-                    if (element == null)
-                    {
-                        
-                        array.Add(EventQueueHelper.KeepAliveEvent());
-                    }
-                    else
-                    {
-                        array.Add(element);
-                        while (queue.Count() > 0)
-                        {
-                            array.Add(queue.Dequeue(1));
-                            thisID++;
-                        }
-                    }
-                    OSDMap events = new OSDMap();
-                    events.Add("events", array);
-
-                    events.Add("id", new LLSDInteger(thisID));
-                    
-                    lock (m_ids)
-                    {
-                        m_ids[AvatarID] = thisID + 1;
-                    }
-                    
-                    return events;
-                }
-                else
-                {
-                    return new LLSD();
-                }
-* 
-*/
-            }
-            else
-            {
-                //return new LLSD();
-            }
-            
-            return new OSDString("shutdown404!");
-        }
-
+/* 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)
@@ -732,7 +518,7 @@ namespace OpenSim.Region.ClientStack.Linden
         }
 
         public virtual void EstablishAgentCommunication(UUID avatarID, IPEndPoint endPoint, string capsPath,
-                                ulong regionHandle, int regionSizeX, int regionSizeY) 
+                                ulong regionHandle, int regionSizeX, int regionSizeY)
         {
             if (DebugLevel > 0)
                 m_log.DebugFormat("{0} EstablishAgentCommunication. handle={1}, endPoint={2}, avatarID={3}",
@@ -742,9 +528,9 @@ namespace OpenSim.Region.ClientStack.Linden
             Enqueue(item, avatarID);
         }
 
-        public virtual void TeleportFinishEvent(ulong regionHandle, byte simAccess, 
+        public virtual void TeleportFinishEvent(ulong regionHandle, byte simAccess,
                                         IPEndPoint regionExternalEndPoint,
-                                        uint locationID, uint flags, string capsURL, 
+                                        uint locationID, uint flags, string capsURL,
                                         UUID avatarID, int regionSizeX, int regionSizeY)
         {
             if (DebugLevel > 0)
@@ -774,33 +560,40 @@ namespace OpenSim.Region.ClientStack.Linden
                                          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, 
+            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 anotherAgent, bool canVoiceChat, 
-                                                      bool isModerator, bool textMute)
+        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);
-            Enqueue(item, fromAgent);
+                                                                          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 GroupMembership(AgentGroupDataUpdatePacket groupUpdate, UUID avatarID)
+        public void GroupMembershipData(UUID receiverAgent, GroupMembershipData[] data)
         {
-            OSD item = EventQueueHelper.GroupMembership(groupUpdate);
-            Enqueue(item, avatarID);
+            OSD item = EventQueueHelper.GroupMembershipData(receiverAgent, data);
+            Enqueue(item, receiverAgent);
         }
 
         public void QueryReply(PlacesReplyPacket groupUpdate, UUID avatarID)
@@ -827,4 +620,4 @@ namespace OpenSim.Region.ClientStack.Linden
             Enqueue(item, avatarID);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
index 384af74..461f776 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
@@ -32,6 +32,8 @@ using OpenMetaverse.Packets;
 using OpenMetaverse.StructuredData;
 using OpenMetaverse.Messages.Linden;
 
+using OpenSim.Framework;
+
 namespace OpenSim.Region.ClientStack.Linden
 {
     public class EventQueueHelper
@@ -76,9 +78,9 @@ namespace OpenSim.Region.ClientStack.Linden
 
             llsdSimInfo.Add("Handle", new OSDBinary(ulongToByteArray(handle)));
             llsdSimInfo.Add("IP", new OSDBinary(endPoint.Address.GetAddressBytes()));
-            llsdSimInfo.Add("Port", new OSDInteger(endPoint.Port));
-            llsdSimInfo.Add("RegionSizeX", OSD.FromUInteger((uint) regionSizeX));
-            llsdSimInfo.Add("RegionSizeY", OSD.FromUInteger((uint) regionSizeY));
+            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);
@@ -88,7 +90,7 @@ namespace OpenSim.Region.ClientStack.Linden
 
             return BuildEvent("EnableSimulator", llsdBody);
         }
-
+/*
         public static OSD DisableSimulator(ulong handle)
         {
             //OSDMap llsdSimInfo = new OSDMap(1);
@@ -103,7 +105,7 @@ namespace OpenSim.Region.ClientStack.Linden
 
             return BuildEvent("DisableSimulator", llsdBody);
         }
-        
+*/
         public static OSD CrossRegion(ulong handle, Vector3 pos, Vector3 lookAt,
                                       IPEndPoint newRegionExternalEndPoint,
                                       string capsURL, UUID agentID, UUID sessionID,
@@ -157,6 +159,12 @@ namespace OpenSim.Region.ClientStack.Linden
                         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?
@@ -165,7 +173,8 @@ namespace OpenSim.Region.ClientStack.Linden
             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.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));
 
@@ -185,13 +194,13 @@ namespace OpenSim.Region.ClientStack.Linden
             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);
         }
 
@@ -204,8 +213,8 @@ namespace OpenSim.Region.ClientStack.Linden
                                   {"sim-ip-and-port", new OSDString(simIpAndPort)},
                                   {"seed-capability", new OSDString(seedcap)},
                                   {"region-handle", OSD.FromULong(regionHandle)},
-                                  {"region-size-x", OSD.FromInteger(regionSizeX)},
-                                  {"region-size-y", OSD.FromInteger(regionSizeY)}
+                                  {"region-size-x", OSD.FromUInteger((uint)regionSizeX)},
+                                  {"region-size-y", OSD.FromUInteger((uint)regionSizeY)}
                               };
 
             return BuildEvent("EstablishAgentCommunication", body);
@@ -234,7 +243,7 @@ namespace OpenSim.Region.ClientStack.Linden
         {
             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));
@@ -299,20 +308,29 @@ namespace OpenSim.Region.ClientStack.Linden
         }
 
         public static OSD ChatterBoxSessionAgentListUpdates(UUID sessionID,
-            UUID agentID, bool canVoiceChat, bool isModerator, bool textMute)
+            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());
@@ -324,40 +342,54 @@ namespace OpenSim.Region.ClientStack.Linden
             return chatterBoxSessionAgentListUpdates;
         }
 
-        public static OSD GroupMembership(AgentGroupDataUpdatePacket groupUpdatePacket)
+        public static OSD ChatterBoxForceClose(UUID sessionID, string reason)
         {
-            OSDMap groupUpdate = new OSDMap();
-            groupUpdate.Add("message", OSD.FromString("AgentGroupDataUpdate"));
+            OSDMap body = new OSDMap(2);
+            body.Add("session_id", new OSDUUID(sessionID));
+            body.Add("reason", new OSDString(reason));
 
-            OSDMap body = new OSDMap();
-            OSDArray agentData = new OSDArray();
-            OSDMap agentDataMap = new OSDMap();
-            agentDataMap.Add("AgentID", OSD.FromUUID(groupUpdatePacket.AgentData.AgentID));
-            agentData.Add(agentDataMap);
-            body.Add("AgentData", agentData);
+            OSDMap chatterBoxForceClose = new OSDMap(2);
+            chatterBoxForceClose.Add("message", new OSDString("ForceCloseChatterBoxSession"));
+            chatterBoxForceClose.Add("body", body);
+            return chatterBoxForceClose;
+        }
 
-            OSDArray groupData = new OSDArray();
+        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);
 
-            foreach (AgentGroupDataUpdatePacket.GroupDataBlock groupDataBlock in groupUpdatePacket.GroupData)
+            OSDArray GroupData = new OSDArray(data.Length);
+            OSDArray NewGroupData = new OSDArray(data.Length);
+
+            foreach (GroupMembershipData membership in data)
             {
-                OSDMap groupDataMap = new OSDMap();
-                groupDataMap.Add("ListInProfile", OSD.FromBoolean(false));
-                groupDataMap.Add("GroupID", OSD.FromUUID(groupDataBlock.GroupID));
-                groupDataMap.Add("GroupInsigniaID", OSD.FromUUID(groupDataBlock.GroupInsigniaID));
-                groupDataMap.Add("Contribution", OSD.FromInteger(groupDataBlock.Contribution));
-                groupDataMap.Add("GroupPowers", OSD.FromBinary(ulongToByteArray(groupDataBlock.GroupPowers)));
-                groupDataMap.Add("GroupName", OSD.FromString(Utils.BytesToString(groupDataBlock.GroupName)));
-                groupDataMap.Add("AcceptNotices", OSD.FromBoolean(groupDataBlock.AcceptNotices));
+                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);
+            }
 
-                groupData.Add(groupDataMap);
+            OSDMap llDataStruct = new OSDMap(3);
+            llDataStruct.Add("AgentData", AgentData);
+            llDataStruct.Add("GroupData", GroupData);
+            llDataStruct.Add("NewGroupData", NewGroupData);
 
-            }
-            body.Add("GroupData", groupData);
-            groupUpdate.Add("body", body);
+            return BuildEvent("AgentGroupDataUpdate", llDataStruct);
 
-            return groupUpdate;
         }
-        
+
         public static OSD PlacesQuery(PlacesReplyPacket PlacesReply)
         {
             OSDMap placesReply = new OSDMap();
@@ -391,7 +423,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 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);
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs
index 16a902d..ee3f4f1 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs
@@ -71,7 +71,6 @@ namespace OpenSim.Region.ClientStack.Linden.Tests
 
             IConfigSource config = new IniConfigSource();
             config.AddConfig("Startup");
-            config.Configs["Startup"].Set("EventQueue", "true");
 
             CapabilitiesModule capsModule = new CapabilitiesModule();
             m_eqgMod = new EventQueueGetModule();
@@ -126,6 +125,15 @@ namespace OpenSim.Region.ClientStack.Linden.Tests
 
             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"]);
@@ -172,7 +180,7 @@ namespace OpenSim.Region.ClientStack.Linden.Tests
             TestHelpers.InMethod();
 //            TestHelpers.EnableLogging();
 
-            UUID npcId 
+            UUID npcId
                 = m_npcMod.CreateNPC(
                     "John", "Smith", new Vector3(128, 128, 30), UUID.Zero, true, m_scene, new AvatarAppearance());
 
@@ -187,4 +195,4 @@ namespace OpenSim.Region.ClientStack.Linden.Tests
             Assert.That((int)eventsResponse["int_response_code"], Is.EqualTo((int)HttpStatusCode.BadGateway));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
index f57d857..ba917e39 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
@@ -27,11 +27,14 @@
 
 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;
@@ -52,15 +55,46 @@ namespace OpenSim.Region.ClientStack.Linden
     {
 //        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
@@ -87,6 +121,7 @@ namespace OpenSim.Region.ClientStack.Linden
             if (m_URL2 != string.Empty)
             {
                 m_Enabled = true;
+
                 m_RedirectURL2 = config.GetString("GetMesh2RedirectURL");
             }
         }
@@ -97,6 +132,8 @@ namespace OpenSim.Region.ClientStack.Linden
                 return;
 
             m_scene = pScene;
+
+            m_assetService = pScene.AssetService;
         }
 
         public void RemoveRegion(Scene scene)
@@ -105,6 +142,9 @@ namespace OpenSim.Region.ClientStack.Linden
                 return;
 
             m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps -= DeregisterCaps;
+            m_scene.EventManager.OnThrottleUpdate -= ThrottleUpdate;
+            m_NumberScenes--;
             m_scene = null;
         }
 
@@ -115,55 +155,302 @@ namespace OpenSim.Region.ClientStack.Linden
 
             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() { }
+        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);
+            }
+        }
 
-        public void RegisterCaps(UUID agentID, Caps caps)
+        // 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 capID = UUID.Random();
-            bool getMeshRegistered = false;
+            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();
+                };
 
-            if (m_URL == string.Empty)
+                // 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;
             }
-            else if (m_URL == "localhost")
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+//            UUID capID = UUID.Random();
+            if (m_URL == "localhost")
             {
-                getMeshRegistered = true;
-                caps.RegisterHandler(
-                    "GetMesh",
-                    new GetMeshHandler("/CAPS/" + capID + "/", m_AssetService, "GetMesh", agentID.ToString(), m_RedirectURL));
+                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);
             }
+        }
 
-            if(m_URL2 == string.Empty)
+        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();
             }
-            else if (m_URL2 == "localhost")
+
+            public bool hasEvents(UUID key, Dictionary<UUID, aPollResponse> responses)
             {
-                if (!getMeshRegistered)
+                PassTime();
+                // Note, this is called IN LOCK
+                bool haskey = responses.ContainsKey(key);
+
+                if (!haskey)
+                {
+                    return false;
+                }
+                aPollResponse response;
+                if (responses.TryGetValue(key, out response))
                 {
-                    caps.RegisterHandler(
-                        "GetMesh2",
-                        new GetMeshHandler("/CAPS/" + capID + "/", m_AssetService, "GetMesh2", agentID.ToString(), m_RedirectURL2));
+                    // Normal
+                    if (BytesSent <= ThrottleBytes)
+                    {
+                        BytesSent += response.bytes;
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
                 }
+                return haskey;
             }
-            else
+
+            public void PassTime()
             {
-                caps.RegisterHandler("GetMesh2", m_URL2);
+                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
index bb932f2..b01c7dc 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
@@ -27,18 +27,13 @@
 
 using System;
 using System.Collections;
-using System.Collections.Specialized;
-using System.Drawing;
-using System.Drawing.Imaging;
+using System.Collections.Generic;
 using System.Reflection;
-using System.IO;
-using System.Web;
+using System.Threading;
 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;
@@ -47,6 +42,7 @@ 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
 {
@@ -54,27 +50,49 @@ namespace OpenSim.Region.ClientStack.Linden
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "GetTextureModule")]
     public class GetTextureModule : INonSharedRegionModule
     {
-//        private static readonly ILog m_log =
-//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
+
+        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 IAssetService m_assetService;
 
-        private bool m_Enabled = false;
+        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>();
 
-        // TODO: Change this to a config option
-        private string m_RedirectURL = null;
+        private Dictionary<UUID,PollServiceTextureEventArgs> m_pollservices = new Dictionary<UUID,PollServiceTextureEventArgs>();
 
-        private string m_URL;
+        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)
@@ -82,39 +100,108 @@ namespace OpenSim.Region.ClientStack.Linden
                 m_Enabled = true;
                 m_RedirectURL = config.GetString("GetTextureRedirectURL");
             }
+*/
+            m_Url = config.GetString("Cap_GetTexture", "localhost");
         }
 
         public void AddRegion(Scene s)
         {
-            if (!m_Enabled)
-                return;
-
             m_scene = s;
+            m_assetService = s.AssetService;
         }
 
         public void RemoveRegion(Scene s)
         {
-            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 s)
         {
-            if (!m_Enabled)
-                return;
+            // We'll reuse the same handler for all requests.
+            m_getTextureHandler = new GetTextureHandler(m_assetService);
 
-            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
             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() { }
+        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"; } }
 
@@ -125,28 +212,277 @@ namespace OpenSim.Region.ClientStack.Linden
 
         #endregion
 
-        public void RegisterCaps(UUID agentID, Caps caps)
+        private class PollServiceTextureEventArgs : PollServiceEventArgs
         {
-            UUID capID = UUID.Random();
+            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();
 
-            //caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
-            if (m_URL == "localhost")
+                    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)
             {
-//                m_log.DebugFormat("[GETTEXTURE]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
-                caps.RegisterHandler(
-                    "GetTexture",
-                    new GetTextureHandler("/CAPS/" + capID + "/", m_assetService, "GetTexture", agentID.ToString(), m_RedirectURL));
+                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();
             }
-            else
+
+            internal void UpdateThrottle(int pimagethrottle)
             {
-//                m_log.DebugFormat("[GETTEXTURE]: {0} in region {1}", m_URL, m_scene.RegionInfo.RegionName);
+                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", m_URL);
+                    handler.RegisterExternalUserCapsHandler(agentID, caps, "GetTexture", capUrl);
                 else
-                    caps.RegisterHandler("GetTexture", m_URL);
+                    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
index 45d33cd..44bf1a5 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs
@@ -129,23 +129,23 @@ namespace OpenSim.Region.ClientStack.Linden
 //            m_log.DebugFormat("[MESH UPLOAD FLAG MODULE]: MeshUploadFlag request");
 
             OSDMap data = new OSDMap();
-            ScenePresence sp = m_scene.GetScenePresence(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"] = agentID;
-            data["is_display_name_default"] = true;
+//          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["int_response_code"] = 200;
             responsedata["content_type"] = "text/plain";
             responsedata["keepalive"] = false;
             responsedata["str_response_string"] = OSDParser.SerializeLLSDXmlString(data);
             return responsedata;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
deleted file mode 100644
index f69a0bb..0000000
--- a/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above 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 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.Framework.Capabilities;
-using PermissionMask = OpenSim.Framework.PermissionMask;
-
-namespace OpenSim.Region.ClientStack.Linden
-{
-    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "NewFileAgentInventoryVariablePriceModule")]
-    public class NewFileAgentInventoryVariablePriceModule : INonSharedRegionModule
-    {
-//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
-        private Scene m_scene;
-//        private IAssetService m_assetService;
-        private bool m_dumpAssetsToFile = false;
-        private bool m_enabled = true;
-        private int  m_levelUpload = 0;
-
-        #region Region Module interfaceBase Members
-
-
-        public Type ReplaceableInterface
-        {
-            get { return null; }
-        }
-
-        public void Initialise(IConfigSource source)
-        {
-            IConfig meshConfig = source.Configs["Mesh"];
-            if (meshConfig == null)
-                return;
-
-            m_enabled = meshConfig.GetBoolean("AllowMeshUpload", true);
-            m_levelUpload = meshConfig.GetInt("LevelUpload", 0);
-        }
-
-        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_assetService = m_scene.RequestModuleInterface<IAssetService>();
-            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
-        }
-
-        #endregion
-
-
-        #region Region Module interface
-
-       
-
-        public void Close() { }
-
-        public string Name { get { return "NewFileAgentInventoryVariablePriceModule"; } }
-
-
-        public void RegisterCaps(UUID agentID, Caps caps)
-        {
-            if(!m_enabled)
-                return;
-
-            UUID capID = UUID.Random();
-
-//            m_log.Debug("[NEW FILE AGENT INVENTORY VARIABLE PRICE]: /CAPS/" + capID);
-            caps.RegisterHandler(
-                "NewFileAgentInventoryVariablePrice",
-                new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDNewFileAngentInventoryVariablePriceReplyResponse>(
-                    "POST",
-                    "/CAPS/" + capID.ToString(),
-                    req => NewAgentInventoryRequest(req, agentID),
-                    "NewFileAgentInventoryVariablePrice",
-                    agentID.ToString()));         
-        }
-
-        #endregion
-
-        public LLSDNewFileAngentInventoryVariablePriceReplyResponse NewAgentInventoryRequest(LLSDAssetUploadRequest llsdRequest, UUID agentID)
-        {
-            //TODO:  The Mesh uploader uploads many types of content. If you're going to implement a Money based limit
-            // you need to be aware of this
-
-            //if (llsdRequest.asset_type == "texture" ||
-           //     llsdRequest.asset_type == "animation" ||
-           //     llsdRequest.asset_type == "sound")
-           // {
-                // check user level
-
-            ScenePresence avatar = null;
-            IClientAPI client = null;
-            m_scene.TryGetScenePresence(agentID, out avatar);
-
-            if (avatar != null)
-            {
-                client = avatar.ControllingClient;
-
-                if (avatar.UserLevel < m_levelUpload)
-                {
-                    if (client != null)
-                        client.SendAgentAlertMessage("Unable to upload asset. Insufficient permissions.", false);
-
-                    LLSDNewFileAngentInventoryVariablePriceReplyResponse errorResponse = new LLSDNewFileAngentInventoryVariablePriceReplyResponse();
-                    errorResponse.rsvp = "";
-                    errorResponse.state = "error";
-                    return errorResponse;
-                }
-            }
-
-            // check funds
-            IMoneyModule mm = m_scene.RequestModuleInterface<IMoneyModule>();
-
-            if (mm != null)
-            {
-                if (!mm.UploadCovered(agentID, mm.UploadCharge))
-                {
-                    if (client != null)
-                        client.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
-
-                    LLSDNewFileAngentInventoryVariablePriceReplyResponse errorResponse = new LLSDNewFileAngentInventoryVariablePriceReplyResponse();
-                    errorResponse.rsvp = "";
-                    errorResponse.state = "error";
-                    return errorResponse;
-                }
-            }
-
-           // }
-
-            string assetName = llsdRequest.name;
-            string assetDes = llsdRequest.description;
-            string capsBase = "/CAPS/NewFileAgentInventoryVariablePrice/";
-            UUID newAsset = UUID.Random();
-            UUID newInvItem = UUID.Random();
-            UUID parentFolder = llsdRequest.folder_id;
-            string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000") + "/";
-
-            AssetUploader uploader =
-                new AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
-                                  llsdRequest.asset_type, capsBase + uploaderPath, MainServer.Instance, m_dumpAssetsToFile);
-
-            MainServer.Instance.AddStreamHandler(
-                new BinaryStreamHandler(
-                    "POST",
-                    capsBase + uploaderPath,
-                    uploader.uploaderCaps,
-                    "NewFileAgentInventoryVariablePrice",
-                    agentID.ToString()));
-
-            string protocol = "http://";
-
-            if (MainServer.Instance.UseSSL)
-                protocol = "https://";
-
-            string uploaderURL = protocol + m_scene.RegionInfo.ExternalHostName + ":" + MainServer.Instance.Port.ToString() + capsBase +
-                                 uploaderPath;
-
-
-            LLSDNewFileAngentInventoryVariablePriceReplyResponse uploadResponse = new LLSDNewFileAngentInventoryVariablePriceReplyResponse();
-            
-            uploadResponse.rsvp = uploaderURL;
-            uploadResponse.state = "upload";
-            uploadResponse.resource_cost = 0;
-            uploadResponse.upload_price = 0;
-
-            uploader.OnUpLoad += //UploadCompleteHandler;
-                
-                delegate(
-                string passetName, string passetDescription, UUID passetID,
-                UUID pinventoryItem, UUID pparentFolder, byte[] pdata, string pinventoryType,
-                string passetType)
-               {
-                   UploadCompleteHandler(passetName, passetDescription,  passetID,
-                                          pinventoryItem, pparentFolder, pdata,  pinventoryType,
-                                          passetType,agentID);
-               };
-
-            return uploadResponse;
-        }
-
-        public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
-                                          UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
-                                          string assetType,UUID AgentID)
-        {
-//            m_log.DebugFormat(
-//                "[NEW FILE AGENT INVENTORY VARIABLE PRICE MODULE]: Upload complete for {0}", inventoryItem);
-
-            sbyte assType = 0;
-            sbyte inType = 0;
-
-            if (inventoryType == "sound")
-            {
-                inType = 1;
-                assType = 1;
-            }
-            else if (inventoryType == "animation")
-            {
-                inType = 19;
-                assType = 20;
-            }
-            else if (inventoryType == "wearable")
-            {
-                inType = 18;
-                switch (assetType)
-                {
-                    case "bodypart":
-                        assType = 13;
-                        break;
-                    case "clothing":
-                        assType = 5;
-                        break;
-                }
-            }
-            else if (inventoryType == "mesh")
-            {
-                inType = (sbyte)InventoryType.Mesh; 
-                assType = (sbyte)AssetType.Mesh;
-            }
-
-            AssetBase asset;
-            asset = new AssetBase(assetID, assetName, assType, AgentID.ToString());
-            asset.Data = data;
-    
-            if (m_scene.AssetService != null)
-                m_scene.AssetService.Store(asset);
-
-            InventoryItemBase item = new InventoryItemBase();
-            item.Owner = AgentID;
-            item.CreatorId = AgentID.ToString();
-            item.ID = inventoryItem;
-            item.AssetID = asset.FullID;
-            item.Description = assetDescription;
-            item.Name = assetName;
-            item.AssetType = assType;
-            item.InvType = inType;
-            item.Folder = parentFolder;
-            item.CurrentPermissions
-                = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
-            item.BasePermissions = (uint)PermissionMask.All;
-            item.EveryOnePermissions = 0;
-            item.NextPermissions = (uint)PermissionMask.All;
-            item.CreationDate = Util.UnixTimeSinceEpoch();
-            m_scene.AddInventoryItem(item);
-        }
-    }
-}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
index 94f8bc1..b044e56 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
@@ -47,7 +47,7 @@ namespace OpenSim.Region.ClientStack.Linden
     {
 //        private static readonly ILog m_log =
 //            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
+
         private Scene m_scene;
 
         #region INonSharedRegionModule Members
@@ -76,7 +76,7 @@ namespace OpenSim.Region.ClientStack.Linden
         }
 
         public void Close()
-        {            
+        {
         }
 
         public string Name
@@ -121,6 +121,9 @@ namespace OpenSim.Region.ClientStack.Linden
 
 
             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;
@@ -157,9 +160,6 @@ namespace OpenSim.Region.ClientStack.Linden
             int state = 0;
             int lastattach = 0;
 
-            if (r.Type != OSDType.Map) // not a proper req
-                return responsedata;
-
             OSDMap rm = (OSDMap)r;
 
             if (rm.ContainsKey("ObjectData")) //v2
@@ -307,8 +307,6 @@ namespace OpenSim.Region.ClientStack.Linden
                 }
             }
 
-
-
             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();
@@ -359,6 +357,8 @@ namespace OpenSim.Region.ClientStack.Linden
             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;
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs
index 769fe28..116c51f 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs
@@ -189,7 +189,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 if (i == 0)
                 {
                     rootpos = obj.Position;
-//                    rootrot = obj.Rotation;                    
+//                    rootrot = obj.Rotation;
                 }
 
                 // Combine the extraparams data into it's ugly blob again....
@@ -284,6 +284,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 prim.OwnerID = AgentId;
                 prim.GroupID = obj.GroupID;
                 prim.LastOwnerID = prim.OwnerID;
+                prim.RezzerID = AgentId;
                 prim.CreationDate = Util.UnixTimeSinceEpoch();
                 prim.Name = obj.Name;
                 prim.Description = "";
@@ -320,7 +321,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 pbs.TextureEntry = tmp.GetBytes();
                 prim.Shape = pbs;
                 prim.Scale = obj.Scale;
-                
+
                 SceneObjectGroup grp = new SceneObjectGroup();
 
                 grp.SetRootPart(prim);
@@ -328,21 +329,22 @@ namespace OpenSim.Region.ClientStack.Linden
                 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;
             }
 
@@ -358,7 +360,7 @@ namespace OpenSim.Region.ClientStack.Linden
             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;
@@ -366,7 +368,7 @@ namespace OpenSim.Region.ClientStack.Linden
 
             return responsedata;
         }
-        
+
         private string ConvertUintToBytes(uint val)
         {
             byte[] resultbytes = Utils.UIntToBytes(val);
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/Properties/AssemblyInfo.cs b/OpenSim/Region/ClientStack/Linden/Caps/Properties/AssemblyInfo.cs
index 0adfa1a..f36826b 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/Properties/AssemblyInfo.cs
@@ -2,7 +2,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-// General Information about an assembly is controlled through the following 
+// 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")]
@@ -14,8 +14,8 @@ using System.Runtime.InteropServices;
 [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 
+// 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)]
 
@@ -25,9 +25,9 @@ using System.Runtime.InteropServices;
 // Version information for an assembly consists of the following four values:
 //
 //      Major Version
-//      Minor Version 
+//      Minor Version
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.8.3.*")]
+[assembly: AssemblyVersion(OpenSim.VersionInfo.AssemblyVersionNumber)]
 
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs
index a133a69..e8387e3 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs
@@ -58,12 +58,14 @@ namespace OpenSim.Region.ClientStack.Linden
     {
 //        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);
@@ -102,7 +104,7 @@ namespace OpenSim.Region.ClientStack.Linden
 
         public void RegisterCaps(UUID agentID, Caps caps)
         {
-            if (!m_scene.RegionInfo.EstateSettings.IsEstateManagerOrOwner(agentID))
+            if (!m_scene.RegionInfo.EstateSettings.IsEstateManagerOrOwner(agentID) && !m_scene.Permissions.IsGod(agentID))
                 return;
 
             UUID capID = UUID.Random();
@@ -118,6 +120,11 @@ namespace OpenSim.Region.ClientStack.Linden
             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)
@@ -148,7 +155,7 @@ namespace OpenSim.Region.ClientStack.Linden
 
             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);
@@ -178,8 +185,9 @@ namespace OpenSim.Region.ClientStack.Linden
 
         protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
         {
-            StreamReader reader = new StreamReader(request);
-            string message = reader.ReadToEnd();
+            string message;
+            using(StreamReader reader = new StreamReader(request))
+                message = reader.ReadToEnd();
 
             OSD osd = OSDParser.DeserializeLLSDXml(message);
 
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
index e258bcb..39f5baf 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
@@ -50,12 +50,12 @@ namespace OpenSim.Region.ClientStack.Linden
     /// 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 : ISharedRegionModule, ISimulatorFeaturesModule
+    public class SimulatorFeaturesModule : INonSharedRegionModule, ISimulatorFeaturesModule
     {
         private static readonly ILog m_log =
             LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
@@ -82,7 +82,7 @@ namespace OpenSim.Region.ClientStack.Linden
             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
@@ -126,10 +126,6 @@ namespace OpenSim.Region.ClientStack.Linden
             GetGridExtraFeatures(s);
         }
 
-        public void PostInitialise()
-        {
-        }
-
         public void Close() { }
 
         public string Name { get { return "SimulatorFeaturesModule"; } }
@@ -155,6 +151,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 m_features["MeshRezEnabled"] = true;
                 m_features["MeshUploadEnabled"] = true;
                 m_features["MeshXferEnabled"] = true;
+
                 m_features["PhysicsMaterialsEnabled"] = true;
 
                 OSDMap typesMap = new OSDMap();
@@ -173,6 +170,10 @@ namespace OpenSim.Region.ClientStack.Linden
                 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))
@@ -250,7 +251,7 @@ namespace OpenSim.Region.ClientStack.Linden
 
             //Send back data
             Hashtable responsedata = new Hashtable();
-            responsedata["int_response_code"] = 200; 
+            responsedata["int_response_code"] = 200;
             responsedata["content_type"] = "text/plain";
             responsedata["keepalive"] = false;
 
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/Tests/WebFetchInvDescModuleTests.cs b/OpenSim/Region/ClientStack/Linden/Caps/Tests/WebFetchInvDescModuleTests.cs
index dd4a691..6ffed4d 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/Tests/WebFetchInvDescModuleTests.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/Tests/WebFetchInvDescModuleTests.cs
@@ -52,6 +52,7 @@ using OSDMap = OpenMetaverse.StructuredData.OSDMap;
 
 namespace OpenSim.Region.ClientStack.Linden.Caps.Tests
 {
+    /*
     [TestFixture]
     public class WebFetchInvDescModuleTests : OpenSimTestCase
     {
@@ -150,10 +151,11 @@ namespace OpenSim.Region.ClientStack.Linden.Caps.Tests
             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
index 8cdebcd..b406b37 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
@@ -63,23 +63,23 @@ namespace OpenSim.Region.ClientStack.Linden
         private static readonly string m_uploadBakedTexturePath = "0010/";// This is in the LandManagementModule.
 
         private Scene m_scene;
-        private bool m_persistBakedTextures;
 
-        private IBakedTextureModule m_BakedTextureModule;
+        private string m_URL;
 
         public void Initialise(IConfigSource source)
         {
-            IConfig appearanceConfig = source.Configs["Appearance"];
-            if (appearanceConfig != null)
-                m_persistBakedTextures = appearanceConfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
+            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)
@@ -87,188 +87,28 @@ namespace OpenSim.Region.ClientStack.Linden
             s.EventManager.OnRegisterCaps -= RegisterCaps;
             s.EventManager.OnNewPresence -= RegisterNewPresence;
             s.EventManager.OnRemovePresence -= DeRegisterPresence;
-            m_BakedTextureModule = null;
             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)
         {
-            ScenePresence presence = null;
-            if (m_scene.TryGetScenePresence(agentId, out presence))
-            {
-                presence.ControllingClient.OnSetAppearance -= CaptureAppearanceSettings;
-            }
-
         }
 
         private void RegisterNewPresence(ScenePresence presence)
         {
-           presence.ControllingClient.OnSetAppearance += CaptureAppearanceSettings;
-
-        }
-
-        private void CaptureAppearanceSettings(IClientAPI remoteClient, Primitive.TextureEntry textureEntry, byte[] visualParams, Vector3 avSize, WearableCacheItem[] cacheItems)
-        {
-            int maxCacheitemsLoop = cacheItems.Length;
-            if (maxCacheitemsLoop > AvatarWearable.MAX_WEARABLES)
-            {
-                maxCacheitemsLoop = AvatarWearable.MAX_WEARABLES;
-                m_log.WarnFormat("[CACHEDBAKES]: Too Many Cache items Provided {0}, the max is {1}.  Truncating!", cacheItems.Length, AvatarWearable.MAX_WEARABLES);
-            }
-
-            m_BakedTextureModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
-            if (cacheItems.Length > 0)
-            {
-//                m_log.Debug("[Cacheitems]: " + cacheItems.Length);
-//                for (int iter = 0; iter < maxCacheitemsLoop; iter++)
-//                {
-//                    m_log.Debug("[Cacheitems] {" + iter + "/" + cacheItems[iter].TextureIndex + "}: c-" + cacheItems[iter].CacheId + ", t-" +
-//                                      cacheItems[iter].TextureID);
-//                }
-               
-                ScenePresence p = null;
-                if (m_scene.TryGetScenePresence(remoteClient.AgentId, out p))
-                {
-
-                    WearableCacheItem[] existingitems = p.Appearance.WearableCacheItems;
-                    if (existingitems == null)
-                    {
-                        if (m_BakedTextureModule != null)
-                        {
-                            WearableCacheItem[] savedcache = null;
-                            try
-                            {
-                                if (p.Appearance.WearableCacheItemsDirty)
-                                {
-                                    savedcache = m_BakedTextureModule.Get(p.UUID);
-                                    p.Appearance.WearableCacheItems = savedcache;
-                                    p.Appearance.WearableCacheItemsDirty = false;
-                                }
-
-                            }
-                            /*
-                             * The following Catch types DO NOT WORK with m_BakedTextureModule.Get
-                             * it jumps to the General Packet Exception Handler if you don't catch Exception!
-                             * 
-                            catch (System.Net.Sockets.SocketException)
-                            {
-                                cacheItems = null;
-                            }
-                            catch (WebException)
-                            {
-                                cacheItems = null;
-                            }
-                            catch (InvalidOperationException)
-                            {
-                                cacheItems = null;
-                            } */
-                            catch (Exception)
-                            {
-                               // The service logs a sufficient error message.
-                            }
-                            
-
-                            if (savedcache != null)
-                                existingitems = savedcache;
-                        }
-                    }
-                    // Existing items null means it's a fully new appearance
-                    if (existingitems == null)
-                    {
-
-                        for (int i = 0; i < maxCacheitemsLoop; i++)
-                        {
-                            if (textureEntry.FaceTextures.Length > cacheItems[i].TextureIndex)
-                            {
-                                Primitive.TextureEntryFace face = textureEntry.FaceTextures[cacheItems[i].TextureIndex];
-                                if (face == null)
-                                {
-                                    textureEntry.CreateFace(cacheItems[i].TextureIndex);
-                                    textureEntry.FaceTextures[cacheItems[i].TextureIndex].TextureID =
-                                        AppearanceManager.DEFAULT_AVATAR_TEXTURE;
-                                    continue;
-                                }
-                                cacheItems[i].TextureID =face.TextureID;
-                                if (m_scene.AssetService != null)
-                                    cacheItems[i].TextureAsset =
-                                        m_scene.AssetService.GetCached(cacheItems[i].TextureID.ToString());
-                            }
-                            else
-                            {
-                                m_log.WarnFormat("[CACHEDBAKES]: Invalid Texture Index Provided, Texture doesn't exist or hasn't been uploaded yet {0}, the max is {1}.  Skipping!", cacheItems[i].TextureIndex, textureEntry.FaceTextures.Length);
-                            }
-
-
-                        }
-                    }
-                    else
-
-
-                    {
-                        // for each uploaded baked texture
-                        for (int i = 0; i < maxCacheitemsLoop; i++)
-                        {
-                            if (textureEntry.FaceTextures.Length > cacheItems[i].TextureIndex)
-                            {
-                                Primitive.TextureEntryFace face = textureEntry.FaceTextures[cacheItems[i].TextureIndex];
-                                if (face == null)
-                                {
-                                    textureEntry.CreateFace(cacheItems[i].TextureIndex);
-                                    textureEntry.FaceTextures[cacheItems[i].TextureIndex].TextureID =
-                                        AppearanceManager.DEFAULT_AVATAR_TEXTURE;
-                                    continue;
-                                }
-                                cacheItems[i].TextureID =
-                                    face.TextureID;
-                            }
-                            else
-                            {
-                                m_log.WarnFormat("[CACHEDBAKES]: Invalid Texture Index Provided, Texture doesn't exist or hasn't been uploaded yet {0}, the max is {1}.  Skipping!", cacheItems[i].TextureIndex, textureEntry.FaceTextures.Length);
-                            }
-                        }
-
-                        for (int i = 0; i < maxCacheitemsLoop; i++)
-                        {
-                            if (cacheItems[i].TextureAsset == null)
-                            {
-                                cacheItems[i].TextureAsset =
-                                    m_scene.AssetService.GetCached(cacheItems[i].TextureID.ToString());
-                            }
-                        }
-                    }
-
-
-
-                    p.Appearance.WearableCacheItems = cacheItems;
-                    
-                   
-
-                    if (m_BakedTextureModule != null)
-                    {
-                        m_BakedTextureModule.Store(remoteClient.AgentId, cacheItems);
-                        p.Appearance.WearableCacheItemsDirty = true;
-                        
-                    }
-                }
-            }
         }
 
         public void PostInitialise()
         {
         }
 
-
-
         public void Close() { }
 
         public string Name { get { return "UploadBakedTextureModule"; } }
@@ -280,23 +120,26 @@ namespace OpenSim.Region.ClientStack.Linden
 
         public void RegisterCaps(UUID agentID, Caps caps)
         {
-            UploadBakedTextureHandler avatarhandler = new UploadBakedTextureHandler(
-                caps, m_scene.AssetService, m_persistBakedTextures);
+            //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,
+                caps.RegisterHandler(
                     "UploadBakedTexture",
-                    agentID.ToString()));
-
-           
-            
+                    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
index 025ffea..8d4e561 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
@@ -34,9 +34,7 @@ using log4net;
 using Nini.Config;
 using Mono.Addins;
 using OpenMetaverse;
-using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
-using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Region.Framework.Interfaces;
@@ -45,6 +43,9 @@ 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
 {
@@ -63,7 +64,7 @@ namespace OpenSim.Region.ClientStack.Linden
             public List<UUID> folders;
         }
 
-         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         /// <summary>
         /// Control whether requests will be processed asynchronously.
@@ -92,14 +93,16 @@ namespace OpenSim.Region.ClientStack.Linden
         private bool m_Enabled;
 
         private string m_fetchInventoryDescendents2Url;
-        private string m_webFetchInventoryDescendentsUrl;
+//        private string m_webFetchInventoryDescendentsUrl;
 
         private static FetchInvDescHandler m_webFetchHandler;
 
         private static Thread[] m_workerThreads = null;
 
-        private static DoubleQueue<aPollRequest> m_queue =
-                new DoubleQueue<aPollRequest>();
+        private static OpenSim.Framework.BlockingQueue<aPollRequest> m_queue =
+                new OpenSim.Framework.BlockingQueue<aPollRequest>();
+
+        private static int m_NumberScenes = 0;
 
         #region ISharedRegionModule Members
 
@@ -117,9 +120,10 @@ namespace OpenSim.Region.ClientStack.Linden
                 return;
 
             m_fetchInventoryDescendents2Url = config.GetString("Cap_FetchInventoryDescendents2", string.Empty);
-            m_webFetchInventoryDescendentsUrl = config.GetString("Cap_WebFetchInventoryDescendents", 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_webFetchInventoryDescendentsUrl != string.Empty)
+            if (m_fetchInventoryDescendents2Url != string.Empty)
             {
                 m_Enabled = true;
             }
@@ -143,17 +147,7 @@ namespace OpenSim.Region.ClientStack.Linden
             StatsManager.DeregisterStat(s_processedRequestsStat);
             StatsManager.DeregisterStat(s_queuedRequestsStat);
 
-            if (ProcessQueuedRequestsAsync)
-            {
-                if (m_workerThreads != null)
-                {
-                    foreach (Thread t in m_workerThreads)
-                        Watchdog.AbortThread(t.ManagedThreadId);
-
-                    m_workerThreads = null;
-                }
-            }
-
+            m_NumberScenes--;
             Scene = null;
         }
 
@@ -187,7 +181,7 @@ namespace OpenSim.Region.ClientStack.Linden
                         "httpfetch",
                         StatType.Pull,
                         MeasuresOfInterest.AverageChangeOverTime,
-                        stat => { stat.Value = m_queue.Count; },
+                        stat => { stat.Value = m_queue.Count(); },
                         StatVerbosity.Debug);
 
             StatsManager.RegisterStat(s_processedRequestsStat);
@@ -201,6 +195,8 @@ namespace OpenSim.Region.ClientStack.Linden
 
             Scene.EventManager.OnRegisterCaps += RegisterCaps;
 
+            m_NumberScenes++;
+
             int nworkers = 2; // was 2
             if (ProcessQueuedRequestsAsync && m_workerThreads == null)
             {
@@ -211,7 +207,7 @@ namespace OpenSim.Region.ClientStack.Linden
                     m_workerThreads[i] = WorkManager.StartThread(DoInventoryRequests,
                             String.Format("InventoryWorkerThread{0}", i),
                             ThreadPriority.Normal,
-                            false,
+                            true,
                             true,
                             null,
                             int.MaxValue);
@@ -223,7 +219,23 @@ namespace OpenSim.Region.ClientStack.Linden
         {
         }
 
-        public void Close() { }
+        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"; } }
 
@@ -312,16 +324,17 @@ namespace OpenSim.Region.ClientStack.Linden
                         {
                             if (!reqinfo.folders.Contains(folderID))
                             {
-                                //TODO: Port COF handling from Avination
+                                if (sp.COF != UUID.Zero && sp.COF == folderID)
+                                    highPriority = true;
                                 reqinfo.folders.Add(folderID);
                             }
                         }
                     }
 
                     if (highPriority)
-                        m_queue.EnqueueHigh(reqinfo);
+                        m_queue.PriorityEnqueue(reqinfo);
                     else
-                        m_queue.EnqueueLow(reqinfo);
+                        m_queue.Enqueue(reqinfo);
                 };
 
                 NoEvents = (x, y) =>
@@ -347,6 +360,9 @@ namespace OpenSim.Region.ClientStack.Linden
 
             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();
@@ -365,7 +381,8 @@ namespace OpenSim.Region.ClientStack.Linden
                         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++;
             }
         }
@@ -422,31 +439,25 @@ namespace OpenSim.Region.ClientStack.Linden
 //            }
 //        }
 
-        private void DoInventoryRequests()
+        private static void DoInventoryRequests()
         {
             while (true)
             {
+                aPollRequest poolreq = m_queue.Dequeue(4500);
                 Watchdog.UpdateThread();
 
-                WaitProcessQueuedInventoryRequest();
-            }
-        }
-
-        public void WaitProcessQueuedInventoryRequest()
-        {
-            aPollRequest poolreq = m_queue.Dequeue();
-
-            if (poolreq != null && poolreq.thepoll != null)
-            {
-                try
-                {
-                    poolreq.thepoll.Process(poolreq);
-                }
-                catch (Exception e)
+                if (poolreq != null && poolreq.thepoll != null)
                 {
-                    m_log.ErrorFormat(
-                        "[INVENTORY]: Failed to process queued inventory request {0} for {1} in {2}.  Exception {3}", 
-                        poolreq.reqID, poolreq.presence != null ? poolreq.presence.Name : "unknown", Scene.Name, e);
+                    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/J2KImage.cs b/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs
index 4d0568d..0a6785c 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs
@@ -98,7 +98,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         }
 
         /// <summary>
-        /// Sends packets for this texture to a client until packetsToSend is 
+        /// 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>
@@ -198,7 +198,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         m_currentPacket = m_stopPacket;
                         return;
                     }
-                    
+
                     if (DiscardLevel >= 0 || m_stopPacket == 0)
                     {
                         // This shouldn't happen, but if it does, we really can't proceed
@@ -234,6 +234,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             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;
                     }
                 }
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index b17b822..2ff6ced 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -62,7 +62,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     /// Handles new client connections
     /// Constructor takes a single Packet and authenticates everything
     /// </summary>
-    public class LLClientView : IClientAPI, IClientCore, IClientIM, IClientChat, IClientInventory, IStatsCollector
+    public class LLClientView : IClientAPI, IClientCore, IClientIM, IClientChat, IClientInventory, IStatsCollector, IClientIPEndpoint
     {
         /// <value>
         /// Debug packet level.  See OpenSim.RegisterConsoleCommands() for more details.
@@ -80,6 +80,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         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;
@@ -100,6 +101,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         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;
@@ -127,6 +129,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         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;
@@ -156,6 +159,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         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;
@@ -250,7 +254,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public event ClassifiedInfoRequest OnClassifiedInfoRequest;
         public event ClassifiedInfoUpdate OnClassifiedInfoUpdate;
         public event ClassifiedDelete OnClassifiedDelete;
-        public event ClassifiedDelete OnClassifiedGodDelete;
+        public event ClassifiedGodDelete OnClassifiedGodDelete;
         public event EventNotificationAddRequest OnEventNotificationAddRequest;
         public event EventNotificationRemoveRequest OnEventNotificationRemoveRequest;
         public event EventGodDelete OnEventGodDelete;
@@ -281,10 +285,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         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;
@@ -319,6 +325,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// </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;
@@ -333,26 +340,27 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         private PriorityQueue m_entityProps;
         private Prioritizer m_prioritizer;
         private bool m_disableFacelights = false;
-        private volatile bool m_justEditedTerrain = false;
-        /// <value>
-        /// List used in construction of data blocks for an object update packet.  This is to stop us having to
-        /// continually recreate it.
-        /// </value>
-        protected List<ObjectUpdatePacket.ObjectDataBlock> m_fullUpdateDataBlocksBuilder;
+
+        // 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 a lock
+        /// All manipulation of this set has to occur under an m_entityUpdates.SyncRoot lock
         ///
         /// </value>
-        protected HashSet<uint> m_killRecord;
+        protected List<uint> m_killRecord;
 
 //        protected HashSet<uint> m_attachmentsSent;
 
-        private int m_animationSequenceNumber = 1;
+        private bool m_deliverPackets = true;
+
         private bool m_SendLogoutPacketWhenClosing = true;
 
         /// <summary>
@@ -371,7 +379,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         protected Scene m_scene;
         protected string m_firstName;
         protected string m_lastName;
-        protected Thread m_clientThread;
         protected Vector3 m_startpos;
         protected UUID m_activeGroupID;
         protected string m_activeGroupName = String.Empty;
@@ -398,18 +405,36 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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; } private set { m_activeGroupID = value; } }
-        public string ActiveGroupName { get { return m_activeGroupName; } private set { m_activeGroupName = value; } }
-        public ulong ActiveGroupPowers { get { return m_activeGroupPowers; } private set { m_activeGroupPowers = value; } }
+        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>
@@ -426,7 +451,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public string Name { get { return FirstName + " " + LastName; } }
 
         public uint CircuitCode { get { return m_circuitCode; } }
-        public int NextAnimationSequenceNumber { get { return m_animationSequenceNumber++; } }
+        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
@@ -447,8 +475,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             set { m_disableFacelights = value; }
         }
 
+        public List<uint> SelectedObjects {get; private set;}
+
         public bool SendLogoutPacketWhenClosing { set { m_SendLogoutPacketWhenClosing = value; } }
 
+
         #endregion Properties
 
 //        ~LLClientView()
@@ -465,6 +496,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 //            DebugPacketLevel = 1;
 
             CloseSyncLock = new Object();
+            SelectedObjects = new List<uint>();
 
             RegisterInterface<IClientIM>(this);
             RegisterInterface<IClientInventory>(this);
@@ -473,8 +505,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_scene = scene;
             m_entityUpdates = new PriorityQueue(m_scene.Entities.Count);
             m_entityProps = new PriorityQueue(m_scene.Entities.Count);
-            m_fullUpdateDataBlocksBuilder = new List<ObjectUpdatePacket.ObjectDataBlock>();
-            m_killRecord = new HashSet<uint>();
+            m_killRecord = new List<uint>();
 //            m_attachmentsSent = new HashSet<uint>();
 
             m_assetService = m_scene.RequestModuleInterface<IAssetService>();
@@ -498,18 +529,23 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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(false);
+            Close(true, false);
         }
 
-        public void Close(bool force)
+        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.
@@ -519,14 +555,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 // 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", 
+                    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();
+                CloseWithoutChecks(sendStop);
             }
         }
 
@@ -539,19 +575,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         ///
         /// Callers must lock ClosingSyncLock before calling.
         /// </remarks>
-        public void CloseWithoutChecks()
+        public void CloseWithoutChecks(bool sendStop)
         {
             m_log.DebugFormat(
                 "[CLIENT]: Close has been called for {0} attached to scene {1}",
                 Name, m_scene.RegionInfo.RegionName);
 
-            // Shutdown the image manager
-            ImageManager.Close();
+            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);
@@ -565,11 +608,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             //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();
 
-            //m_log.InfoFormat("[CLIENTVIEW] Memory pre  GC {0}", System.GC.GetTotalMemory(false));
-            //GC.Collect();
-            //m_log.InfoFormat("[CLIENTVIEW] Memory post GC {0}", System.GC.GetTotalMemory(true));
+            // 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)
@@ -648,36 +706,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <returns>true if the handler was added.  This is currently always the case.</returns>
         public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler, bool doAsync)
         {
-            return AddLocalPacketHandler(packetType, handler, doAsync, false);
-        }
-
-        /// <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 handle it on a different thread.  Whether this is given direct to 
-        /// a threadpool thread or placed in a queue depends on the inEngine parameter.
-        /// </param>
-        /// <param name="inEngine">
-        /// If async is false then this parameter is ignored.
-        /// If async is true and inEngine is false, then the packet is sent directly to a
-        /// threadpool thread. 
-        /// If async is true and inEngine is true, then the packet is sent to the IncomingPacketAsyncHandlingEngine.
-        /// This may result in slower handling but reduces the risk of overloading the simulator when there are many
-        /// simultaneous async requests.
-        /// </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 inEngine)
-        {
             bool result = false;
             lock (m_packetHandlers)
             {
                 if (!m_packetHandlers.ContainsKey(packetType))
                 {
                     m_packetHandlers.Add(
-                        packetType, new PacketProcessor() { method = handler, Async = doAsync, InEngine = inEngine });
+                        packetType, new PacketProcessor() { method = handler, Async = doAsync});
                     result = true;
                 }
             }
@@ -712,30 +747,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             PacketProcessor pprocessor;
             if (m_packetHandlers.TryGetValue(packet.Type, out pprocessor))
             {
-                ClientInfo cinfo = UDPClient.GetClientInfo();
 
                 //there is a local handler for this packet type
                 if (pprocessor.Async)
                 {
-                    if (!cinfo.AsyncRequests.ContainsKey(packet.Type.ToString()))
-                        cinfo.AsyncRequests[packet.Type.ToString()] = 0;
-                    cinfo.AsyncRequests[packet.Type.ToString()]++;
-
                     object obj = new AsyncPacketProcess(this, pprocessor.method, packet);
-
-                    if (pprocessor.InEngine)
-                        m_udpServer.IpahEngine.QueueJob(packet.Type.ToString(), () => ProcessSpecificPacketAsync(obj));
-                    else
-                        Util.FireAndForget(ProcessSpecificPacketAsync, obj, packet.Type.ToString());
-
+                    m_asyncPacketProcess.QueueJob(packet.Type.ToString(), () => ProcessSpecificPacketAsync(obj));
                     result = true;
                 }
                 else
                 {
-                    if (!cinfo.SyncRequests.ContainsKey(packet.Type.ToString()))
-                        cinfo.SyncRequests[packet.Type.ToString()] = 0;
-                    cinfo.SyncRequests[packet.Type.ToString()]++;
-
                     result = pprocessor.method(this, packet);
                 }
             }
@@ -750,11 +771,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 }
                 if (found)
                 {
-                    ClientInfo cinfo = UDPClient.GetClientInfo();
-                    if (!cinfo.GenericRequests.ContainsKey(packet.Type.ToString()))
-                        cinfo.GenericRequests[packet.Type.ToString()] = 0;
-                    cinfo.GenericRequests[packet.Type.ToString()]++;
-
                     result = method(this, packet);
                 }
             }
@@ -774,7 +790,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 // 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), 
+                        "[LLCLIENTVIEW]: Caught exception while processing {0} for {1}  ", packetObject.Pack, Name),
                     e);
             }
         }
@@ -785,9 +801,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public virtual void Start()
         {
+            m_asyncPacketProcess.Start();
             m_scene.AddNewAgent(this, PresenceType.User);
 
-            RefreshGroupMembership();
+//            RefreshGroupMembership();
         }
 
         # endregion
@@ -858,6 +875,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         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;
@@ -893,14 +914,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             reply.ChatData.OwnerID = ownerID;
             reply.ChatData.SourceID = fromAgentID;
 
-            OutPacket(reply, ThrottleOutPacketType.Task);
+            OutPacket(reply, ThrottleOutPacketType.Unknown);
         }
 
         /// <summary>
         /// Send an instant message to this client
         /// </summary>
         //
-        // Don't remove transaction ID! Groups and item gives need to set it!
         public void SendInstantMessage(GridInstantMessage im)
         {
             if (((Scene)(m_scene)).Permissions.CanInstantMessage(new UUID(im.fromAgentID), new UUID(im.toAgentID)))
@@ -913,6 +933,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 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
@@ -926,32 +947,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 msg.MessageBlock.Message = Util.StringToBytes1024(im.message);
                 msg.MessageBlock.BinaryBucket = im.binaryBucket;
 
-                if (im.message.StartsWith("[grouptest]"))
-                { // this block is test code for implementing group IM - delete when group IM is finished
-                    IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
-                    if (eq != null)
-                    {
-                        im.dialog = 17;
-
-                        //eq.ChatterboxInvitation(
-                        //    new UUID("00000000-68f9-1111-024e-222222111123"),
-                        //    "OpenSimulator Testing", im.fromAgentID, im.message, im.toAgentID, im.fromAgentName, im.dialog, 0,
-                        //    false, 0, new Vector3(), 1, im.imSessionID, im.fromGroup, im.binaryBucket);
-
-                        eq.ChatterboxInvitation(
-                            new UUID("00000000-68f9-1111-024e-222222111123"),
-                            "OpenSimulator Testing", new UUID(im.fromAgentID), im.message, new UUID(im.toAgentID), im.fromAgentName, im.dialog, 0,
-                            false, 0, new Vector3(), 1, new UUID(im.imSessionID), im.fromGroup, Util.StringToBytes256("OpenSimulator Testing"));
-
-                        eq.ChatterBoxSessionAgentListUpdates(
-                            new UUID("00000000-68f9-1111-024e-222222111123"),
-                            new UUID(im.fromAgentID), new UUID(im.toAgentID), false, false, false);
-                    }
-
-                    Console.WriteLine("SendInstantMessage: " + msg);
-                }
-                else
-                    OutPacket(msg, ThrottleOutPacketType.Task);
+                OutPacket(msg, ThrottleOutPacketType.Task);
             }
         }
 
@@ -1182,6 +1178,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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
@@ -1192,6 +1197,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         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>
@@ -1214,7 +1223,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 //}
 
                 // Send LayerData in a spiral pattern. Fun!
-                SendLayerTopRight(map, 0, 0, map.SizeX/Constants.TerrainPatchSize-1, map.SizeY/Constants.TerrainPatchSize-1);
+                SendLayerTopRight(map, 0, 0, map.SizeX / Constants.TerrainPatchSize - 1, map.SizeY / Constants.TerrainPatchSize - 1);
             }
             catch (Exception e)
             {
@@ -1250,27 +1259,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 SendLayerTopRight(map, x1 + 1, y1, x2, y2 - 1);
         }
 
-        /// <summary>
-        /// Sends a set of four patches (x, x+1, ..., x+3) to the client
-        /// </summary>
-        /// <param name="map">heightmap</param>
-        /// <param name="px">X coordinate for patches 0..12</param>
-        /// <param name="py">Y coordinate for patches 0..15</param>
-        // private void SendLayerPacket(float[] map, int y, int x)
-        // {
-        //     int[] patches = new int[4];
-        //     patches[0] = x + 0 + y * 16;
-        //     patches[1] = x + 1 + y * 16;
-        //     patches[2] = x + 2 + y * 16;
-        //     patches[3] = x + 3 + y * 16;
-
-        //     Packet layerpack = LLClientView.TerrainManager.CreateLandPacket(map, patches);
-        //     OutPacket(layerpack, ThrottleOutPacketType.Land);
-        // }
 
         // 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, 
+        // 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'
@@ -1316,6 +1308,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         }
 
         /// <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.
@@ -1334,32 +1327,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             try
             {
-                /* test code using the terrain compressor in libOpenMetaverse
-                int[] patchInd = new int[1];
-                patchInd[0] = px + (py * Constants.TerrainPatchSize);
-                LayerDataPacket layerpack = TerrainCompressor.CreateLandPacket(terrData.GetFloatsSerialized(), patchInd);
-                 */
-                // Many, many patches could have been passed to us. Since the patches will be compressed
-                //   into variable sized blocks, we cannot pre-compute how many will fit into one
-                //   packet. While some fancy packing algorithm is possible, 4 seems to always fit.
-                int PatchesAssumedToFit = 4;
-                for (int pcnt = 0; pcnt < px.Length; pcnt += PatchesAssumedToFit)
-                {
-                    int remaining = Math.Min(px.Length - pcnt, PatchesAssumedToFit);
-                    int[] xPatches = new int[remaining];
-                    int[] yPatches = new int[remaining];
-                    for (int ii = 0; ii < remaining; ii++)
-                    {
-                        xPatches[ii] = px[pcnt + ii];
-                        yPatches[ii] = py[pcnt + ii];
-                    }
-                    LayerDataPacket layerpack = OpenSimTerrainCompressor.CreateLandPacket(terrData, xPatches, yPatches);
-                    // DebugSendingPatches("SendLayerDataInternal", xPatches, yPatches);
-
-                    SendTheLayerPacket(layerpack);
-                }
-                // LayerDataPacket layerpack = OpenSimTerrainCompressor.CreateLandPacket(terrData, px, py);
+                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)
             {
@@ -1367,110 +1343,125 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
 
-        // When a user edits the terrain, so much data is sent, the data queues up fast and presents a
-        // sub optimal editing experience. To alleviate this issue, when the user edits the terrain, we
-        // start skipping the queues until they're done editing the terrain. We also make them
-        // unreliable because it's extremely likely that multiple packets will be sent for a terrain patch
-        // area invalidating previous packets for that area.
 
-        // It's possible for an editing user to flood themselves with edited packets but the majority
-        // of use cases are such that only a tiny percentage of users will be editing the terrain.
-        // Other, non-editing users will see the edits much slower.
-        
-        // One last note on this topic, by the time users are going to be editing the terrain, it's
-        // extremely likely that the sim will have rezzed already and therefore this is not likely going
-        // to cause any additional issues with lost packets, objects or terrain patches.
+        // wind caching
+        private static Dictionary<ulong,int> lastWindVersion = new Dictionary<ulong,int>();
+        private static Dictionary<ulong,List<LayerDataPacket>> lastWindPackets =
+                 new Dictionary<ulong,List<LayerDataPacket>>();
 
-        // m_justEditedTerrain is volatile, so test once and duplicate two affected statements so we
-        //    only have one cache miss.
-        private void SendTheLayerPacket(LayerDataPacket layerpack)
-        {
-            if (m_justEditedTerrain)
-            {
-                layerpack.Header.Reliable = false;
-                OutPacket(layerpack, ThrottleOutPacketType.Unknown );
-            }
-            else
-            {
-                layerpack.Header.Reliable = true;
-                OutPacket(layerpack, ThrottleOutPacketType.Land);
-            }
-        }
 
         /// <summary>
         ///  Send the wind matrix to the client
         /// </summary>
         /// <param name="windSpeeds">16x16 array of wind speeds</param>
-        public virtual void SendWindData(Vector2[] windSpeeds)
-        {
-            Util.FireAndForget(DoSendWindData, windSpeeds, "LLClientView.SendWindData");
-        }
-
-        /// <summary>
-        ///  Send the cloud matrix to the client
-        /// </summary>
-        /// <param name="windSpeeds">16x16 array of cloud densities</param>
-        public virtual void SendCloudData(float[] cloudDensity)
-        {
-            Util.FireAndForget(DoSendCloudData, cloudDensity, "LLClientView.SendCloudData");
-        }
-
-        /// <summary>
-        /// Send wind layer information to the client.
-        /// </summary>
-        /// <param name="o"></param>
-        private void DoSendWindData(object o)
+        public virtual void SendWindData(int version, Vector2[] windSpeeds)
         {
-            Vector2[] windSpeeds = (Vector2[])o;
-            TerrainPatch[] patches = new TerrainPatch[2];
-            patches[0] = new TerrainPatch { Data = new float[16 * 16] };
-            patches[1] = new TerrainPatch { Data = new float[16 * 16] };
+//            Vector2[] windSpeeds = (Vector2[])o;
 
-            for (int x = 0; x < 16 * 16; x++)
+            ulong handle = this.Scene.RegionInfo.RegionHandle;
+            bool isNewData;
+            lock(lastWindPackets)
             {
-                patches[0].Data[x] = windSpeeds[x].X;
-                patches[1].Data[x] = windSpeeds[x].Y;
+                if(!lastWindVersion.ContainsKey(handle) ||
+                    !lastWindPackets.ContainsKey(handle))
+                {
+                    lastWindVersion[handle] = 0;
+                    lastWindPackets[handle] = new List<LayerDataPacket>();
+                    isNewData = true;
+                }
+                else
+                    isNewData = lastWindVersion[handle] != version;
             }
 
-            byte layerType = (byte)TerrainPatch.LayerType.Wind;
-            if (m_scene.RegionInfo.RegionSizeX > Constants.RegionSize || m_scene.RegionInfo.RegionSizeY > Constants.RegionSize)
-                layerType = (byte)TerrainPatch.LayerType.WindExtended;
+            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;
+                }
+            }
 
-            // LayerDataPacket layerpack = TerrainCompressor.CreateLayerDataPacket(patches, (TerrainPatch.LayerType)layerType);
-            LayerDataPacket layerpack = OpenSimTerrainCompressor.CreateLayerDataPacket(patches, layerType,
-                                (int)m_scene.RegionInfo.RegionSizeX, (int)m_scene.RegionInfo.RegionSizeY);
-            layerpack.Header.Zerocoded = true;
-            OutPacket(layerpack, ThrottleOutPacketType.Wind);
+            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 cloud layer information to the client.
+        ///  Send the cloud matrix to the client
         /// </summary>
-        /// <param name="o"></param>
-        private void DoSendCloudData(object o)
+        /// <param name="windSpeeds">16x16 array of cloud densities</param>
+        public virtual void SendCloudData(int version, float[] cloudDensity)
         {
-            float[] cloudCover = (float[])o;
-            TerrainPatch[] patches = new TerrainPatch[1];
-            patches[0] = new TerrainPatch();
-            patches[0].Data = new float[16 * 16];
-
-            for (int y = 0; y < 16; y++)
+            ulong handle = this.Scene.RegionInfo.RegionHandle;
+            bool isNewData;
+            lock(lastWindPackets)
             {
-                for (int x = 0; x < 16; x++)
+                if(!lastCloudVersion.ContainsKey(handle) ||
+                    !lastCloudPackets.ContainsKey(handle))
                 {
-                    patches[0].Data[y * 16 + x] = cloudCover[y * 16 + x];
+                    lastCloudVersion[handle] = 0;
+                    lastCloudPackets[handle] = new List<LayerDataPacket>();
+                    isNewData = true;
                 }
+                else
+                    isNewData = lastCloudVersion[handle] != version;
             }
 
-            byte layerType = (byte)TerrainPatch.LayerType.Cloud;
-            if (m_scene.RegionInfo.RegionSizeX > Constants.RegionSize || m_scene.RegionInfo.RegionSizeY > Constants.RegionSize)
-                layerType = (byte)TerrainPatch.LayerType.CloudExtended;
+            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;
+                }
+            }
 
-            // LayerDataPacket layerpack = TerrainCompressor.CreateLayerDataPacket(patches, (TerrainPatch.LayerType)layerType);
-            LayerDataPacket layerpack = OpenSimTerrainCompressor.CreateLayerDataPacket(patches, layerType,
-                                (int)m_scene.RegionInfo.RegionSizeX, (int)m_scene.RegionInfo.RegionSizeY);
-            layerpack.Header.Zerocoded = true;
-            OutPacket(layerpack, ThrottleOutPacketType.Cloud);
+            lock(lastCloudPackets)
+                foreach(LayerDataPacket pkt in lastCloudPackets[handle])
+                    OutPacket(pkt, ThrottleOutPacketType.Cloud);
         }
 
         /// <summary>
@@ -1735,45 +1726,59 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             pc.PingID.OldestUnacked = 0;
 
             OutPacket(pc, ThrottleOutPacketType.Unknown);
+            UDPClient.m_lastStartpingTimeMS = Util.EnvironmentTickCount();
         }
 
         public void SendKillObject(List<uint> localIDs)
         {
-//            m_log.DebugFormat("[CLIENT]: Sending KillObjectPacket to {0} for {1} in {2}", Name, localID, regionHandle);
+            //            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);
-            // TODO: don't create new blocks if recycling an old packet
-            kill.ObjectData = new KillObjectPacket.ObjectDataBlock[localIDs.Count];
+
+            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[i] = new KillObjectPacket.ObjectDataBlock();
-                kill.ObjectData[i].ID = localIDs[i];
-            }
-            kill.Header.Reliable = true;
-            kill.Header.Zerocoded = true;
+                kill.ObjectData[nsent] = new KillObjectPacket.ObjectDataBlock();
+                kill.ObjectData[nsent].ID = localIDs[i];
 
-            if (localIDs.Count == 1 && m_scene.GetScenePresence(localIDs[0]) != null)
-            {
-                OutPacket(kill, ThrottleOutPacketType.Task);
-            }
-            else
-            {
-                // We MUST lock for both manipulating the kill record and sending the packet, in order to avoid a race
-                // condition where a kill can be processed before an out-of-date update for the same object.
-                // ProcessEntityUpdates() also takes the m_killRecord lock.
-                lock (m_killRecord)
+                if(++nsent >= 200)
                 {
-                    foreach (uint localID in localIDs)
-                        m_killRecord.Add(localID);
-
-                    // The throttle queue used here must match that being used for updates.  Otherwise, there is a
-                    // chance that a kill packet put on a separate queue will be sent to the client before an existing
-                    // update packet on another queue.  Receiving updates after kills results in unowned and undeletable
-                    // scene objects in a viewer until that viewer is relogged in.
+                    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.
@@ -1895,7 +1900,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             newBlock.CreationDate = item.CreationDate;
             newBlock.SalePrice = item.SalePrice;
             newBlock.SaleType = item.SaleType;
-            newBlock.Flags = item.Flags;
+            newBlock.Flags = item.Flags & 0x2000ff;
 
             newBlock.CRC =
                 Helpers.InventoryCRC(newBlock.CreationDate, newBlock.SaleType,
@@ -2151,7 +2156,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             itemBlock.GroupID = item.GroupID;
             itemBlock.GroupOwned = item.GroupOwned;
             itemBlock.GroupMask = item.GroupPermissions;
-            itemBlock.Flags = item.Flags;
+            itemBlock.Flags = item.Flags & 0x2000ff;
             itemBlock.SalePrice = item.SalePrice;
             itemBlock.SaleType = item.SaleType;
             itemBlock.CreationDate = item.CreationDate;
@@ -2218,7 +2223,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             bulkUpdate.ItemData[0].GroupID = item.GroupID;
             bulkUpdate.ItemData[0].GroupOwned = item.GroupOwned;
             bulkUpdate.ItemData[0].GroupMask = item.GroupPermissions;
-            bulkUpdate.ItemData[0].Flags = item.Flags;
+            bulkUpdate.ItemData[0].Flags = item.Flags & 0x2000ff;
             bulkUpdate.ItemData[0].SalePrice = item.SalePrice;
             bulkUpdate.ItemData[0].SaleType = item.SaleType;
 
@@ -2234,9 +2239,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(bulkUpdate, ThrottleOutPacketType.Asset);
         }
 
-        /// <see>IClientAPI.SendInventoryItemCreateUpdate(InventoryItemBase)</see>
         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
@@ -2246,6 +2256,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // 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;
@@ -2266,7 +2277,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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].Flags = Item.Flags & 0x2000ff;
             InventoryReply.InventoryData[0].SalePrice = Item.SalePrice;
             InventoryReply.InventoryData[0].SaleType = Item.SaleType;
             InventoryReply.InventoryData[0].CreationDate = Item.CreationDate;
@@ -2296,11 +2307,23 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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;
@@ -2315,16 +2338,21 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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)
+        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, ThrottleOutPacketType.Asset);
+            OutPacket(sendXfer, type);
         }
 
         public void SendAbortXferPacket(ulong xferID)
@@ -2415,6 +2443,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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>
@@ -2471,14 +2511,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // this is the username of the *owner*
             dialog.Data.FirstName = Util.StringToBytes256(ownerFirstName);
             dialog.Data.LastName = Util.StringToBytes256(ownerLastName);
-            dialog.Data.Message = Util.StringToBytes1024(msg);
+            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]);
+                buttons[i].ButtonLabel = Util.StringToBytes(buttonlabels[i],24);
             }
             dialog.Buttons = buttons;
 
@@ -2514,6 +2554,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);
@@ -2632,7 +2681,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(packet, ThrottleOutPacketType.Task);
         }
 
-        public void SendAvatarProperties(UUID avatarID, string aboutText, string bornOn, Byte[] charterMember,
+        public void SendAvatarProperties(UUID avatarID, string aboutText, string bornOn, Byte[] membershipType,
                                          string flAbout, uint flags, UUID flImageID, UUID imageID, string profileURL,
                                          UUID partnerID)
         {
@@ -2644,7 +2693,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             else
                 avatarReply.PropertiesData.AboutText = Utils.EmptyBytes;
             avatarReply.PropertiesData.BornOn = Util.StringToBytes256(bornOn);
-            avatarReply.PropertiesData.CharterMember = charterMember;
+            avatarReply.PropertiesData.CharterMember = membershipType;
             if (flAbout != null)
                 avatarReply.PropertiesData.FLAboutText = Util.StringToBytes256(flAbout);
             else
@@ -2730,8 +2779,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(offp, ThrottleOutPacketType.Task);
         }
 
-        public void SendSitResponse(UUID TargetID, Vector3 OffsetPos, Quaternion SitOrientation, bool autopilot,
-                                        Vector3 CameraAtOffset, Vector3 CameraEyeOffset, bool ForceMouseLook)
+        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;
@@ -2763,46 +2828,55 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendGroupMembership(GroupMembershipData[] GroupMembership)
         {
-            m_groupPowers.Clear();
 
-            AgentGroupDataUpdatePacket Groupupdate = new AgentGroupDataUpdatePacket();
-            AgentGroupDataUpdatePacket.GroupDataBlock[] Groups = new AgentGroupDataUpdatePacket.GroupDataBlock[GroupMembership.Length];
-            for (int i = 0; i < GroupMembership.Length; i++)
-            {
-                m_groupPowers[GroupMembership[i].GroupID] = GroupMembership[i].GroupPowers;
+            UpdateGroupMembership(GroupMembership);
+            SendAgentGroupDataUpdate(AgentId,GroupMembership);
+        }
 
-                AgentGroupDataUpdatePacket.GroupDataBlock Group = new AgentGroupDataUpdatePacket.GroupDataBlock();
-                Group.AcceptNotices = GroupMembership[i].AcceptNotices;
-                Group.Contribution = GroupMembership[i].Contribution;
-                Group.GroupID = GroupMembership[i].GroupID;
-                Group.GroupInsigniaID = GroupMembership[i].GroupPicture;
-                Group.GroupName = Util.StringToBytes256(GroupMembership[i].GroupName);
-                Group.GroupPowers = GroupMembership[i].GroupPowers;
-                Groups[i] = Group;
+        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);
 
-            }
-            Groupupdate.GroupData = Groups;
-            Groupupdate.AgentData = new AgentGroupDataUpdatePacket.AgentDataBlock();
-            Groupupdate.AgentData.AgentID = AgentId;
-            OutPacket(Groupupdate, ThrottleOutPacketType.Task);
+            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);
 
-            try
-            {
-                IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
-                if (eq != null)
-                {
-                    eq.GroupMembership(Groupupdate, this.AgentId);
-                }
-            }
-            catch (Exception ex)
+            // caps physics part
+            IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
+            if(eq == null)
+                return;
+
+            OSDArray array = new OSDArray();
+            foreach(SceneObjectPart sop in parts)
             {
-                m_log.Error("Unable to send group membership data via eventqueue - exception: " + ex.ToString());
-                m_log.Warn("sending group membership data via UDP");
-                OutPacket(Groupupdate, ThrottleOutPacketType.Task);
+                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;
@@ -2819,6 +2893,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         float friction = part.Friction;
                         float bounce = part.Restitution;
                         float gravmod = part.GravityModifier;
+
                         eq.partPhysicsProperties(localid, physshapetype, density, friction, bounce, gravmod,AgentId);
                     }
                 }
@@ -2826,7 +2901,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 {
                     m_log.Error("Unable to send part Physics Proprieties - exception: " + ex.ToString());
                 }
-                part.UpdatePhysRequired = false;
             }
         }
 
@@ -2883,6 +2957,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         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",
@@ -2890,7 +2971,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 return;
             }
 
-            //m_log.Debug("sending asset " + req.RequestAssetID);
+            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;
@@ -2912,7 +3004,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             Transfer.TransferInfo.Size = req.AssetInf.Data.Length;
             Transfer.TransferInfo.TransferID = req.TransferRequestID;
             Transfer.Header.Zerocoded = true;
-            OutPacket(Transfer, ThrottleOutPacketType.Asset);
+            OutPacket(Transfer, isWearable ? ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority : ThrottleOutPacketType.Asset);
 
             if (req.NumPackets == 1)
             {
@@ -2923,12 +3015,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 TransferPacket.TransferData.Data = req.AssetInf.Data;
                 TransferPacket.TransferData.Status = 1;
                 TransferPacket.Header.Zerocoded = true;
-                OutPacket(TransferPacket, ThrottleOutPacketType.Asset);
+                OutPacket(TransferPacket, isWearable ? ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority : ThrottleOutPacketType.Asset);
             }
             else
             {
                 int processedLength = 0;
-                int maxChunkSize = Settings.MAX_PACKET_SIZE - 100;
+//                int maxChunkSize = Settings.MAX_PACKET_SIZE - 100;
+
+                int maxChunkSize = (int) MaxTransferBytesPerPacket;
                 int packetNumber = 0;
 
                 while (processedLength < req.AssetInf.Data.Length)
@@ -2954,7 +3048,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         TransferPacket.TransferData.Status = 1;
                     }
                     TransferPacket.Header.Zerocoded = true;
-                    OutPacket(TransferPacket, ThrottleOutPacketType.Asset);
+                    OutPacket(TransferPacket, isWearable ? ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority : ThrottleOutPacketType.Asset);
 
                     processedLength += chunkSize;
                     packetNumber++;
@@ -2990,23 +3084,21 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendParcelInfo(RegionInfo info, LandData land, UUID parcelID, uint x, uint y)
         {
-            float dwell = 0.0f;
-            IDwellModule dwellModule = m_scene.RequestModuleInterface<IDwellModule>();
-            if (dwellModule != null)
-                dwell = dwellModule.GetDwell(land.GlobalID);
             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);
-            reply.Data.Desc = Utils.StringToBytes(land.Description);
+            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?
 
-            // Bit 0: Mature, bit 7: on sale, other bits: no idea
-            reply.Data.Flags = (byte)(
-                (info.AccessLevel > 13 ? (1 << 0) : 0) +
-                ((land.Flags & (uint)ParcelFlags.ForSale) != 0 ? (1 << 7) : 0));
+            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))
@@ -3018,7 +3110,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             reply.Data.GlobalZ = pos.Z;
             reply.Data.SimName = Utils.StringToBytes(info.RegionName);
             reply.Data.SnapshotID = land.SnapshotID;
-            reply.Data.Dwell = dwell;
+            reply.Data.Dwell = land.Dwell;
             reply.Data.SalePrice = land.SalePrice;
             reply.Data.AuctionID = (int)land.AuctionID;
 
@@ -3385,7 +3477,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
              AgentData.Add(AgentDataMap);
              llsd.Add("AgentData", AgentData);
              OSDArray GroupData = new OSDArray(data.Length);
-             OSDArray NewGroupData = new OSDArray(data.Length);
+//             OSDArray NewGroupData = new OSDArray(data.Length);
              foreach (GroupMembershipData m in data)
              {
                  OSDMap GroupDataMap = new OSDMap(6);
@@ -3396,12 +3488,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                  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));
+//                 NewGroupDataMap.Add("ListInProfile", OSD.FromBoolean(m.ListInProfile));
                  GroupData.Add(GroupDataMap);
-                 NewGroupData.Add(NewGroupDataMap);
+//                 NewGroupData.Add(NewGroupDataMap);
              }
              llsd.Add("GroupData", GroupData);
-             llsd.Add("NewGroupData", NewGroupData);
+ //            llsd.Add("NewGroupData", NewGroupData);
 
              IEventQueue eq = this.Scene.RequestModuleInterface<IEventQueue>();
              if (eq != null)
@@ -3410,6 +3502,39 @@ namespace OpenSim.Region.ClientStack.LindenUDP
              }
         }
 
+        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);
@@ -3649,6 +3774,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);
@@ -3706,24 +3847,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);
-                }
-            }
+                    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);
+            OutPacket(aw, ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority);
         }
 
         public void SendAppearance(UUID agentID, byte[] visualParams, byte[] textureEntry)
@@ -3749,8 +3891,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);
+            OutPacket(avp, ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority);
         }
 
         public void SendAnimations(UUID[] animations, int[] seqs, UUID sourceAgentId, UUID[] objectIDs)
@@ -3778,7 +3925,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     ani.AnimationSourceList[i].ObjectID = objectIDs[i];
             }
             ani.Header.Reliable = false;
-            OutPacket(ani, ThrottleOutPacketType.Task);
+            OutPacket(ani, ThrottleOutPacketType.Task | ThrottleOutPacketType.HighPriority);
         }
 
         #endregion
@@ -3788,26 +3935,70 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>
         /// Send an ObjectUpdate packet with information about an avatar
         /// </summary>
-        public void SendAvatarDataImmediate(ISceneEntity avatar)
+        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);
-            
-            ScenePresence presence = avatar as ScenePresence;
-            if (presence == null)
+
+            if (ent == null)
                 return;
 
             ObjectUpdatePacket objupdate = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);
             objupdate.Header.Zerocoded = true;
 
-            objupdate.RegionData.RegionHandle = presence.RegionHandle;
-            objupdate.RegionData.TimeDilation = ushort.MaxValue;
-            
+            objupdate.RegionData.TimeDilation = Utils.FloatToUInt16(m_scene.TimeDilation, 0.0f, 1.0f);
             objupdate.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
-            objupdate.ObjectData[0] = CreateAvatarUpdateBlock(presence);
 
-            OutPacket(objupdate, ThrottleOutPacketType.Task);
+            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);
@@ -3859,13 +4050,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         #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
@@ -3876,21 +4067,38 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[1];
                 packet.ObjectData[0] = CreateImprovedTerseBlock(entity, false);
                 OutPacket(packet, ThrottleOutPacketType.Unknown, true);
+                return;
             }
-            else
+*/
+            if (entity is SceneObjectPart)
             {
-                //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, m_scene.TimeDilation));
+                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. 
+        /// 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)
@@ -3904,9 +4112,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         }
 
         /// <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. 
+        /// 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)
@@ -3919,7 +4127,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);           
+            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
@@ -3929,335 +4137,515 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 ResendPrimUpdate(update);
         }
 
-//        OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>> objectUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>>();
-//        OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>> compressedUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>>();
-//        OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();
-//        OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseAgentUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();
-//
-//        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>>();
-
+        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 maxUpdates)
+        private void ProcessEntityUpdates(int maxUpdatesBytes)
         {
-            OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>> objectUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>>();
-            OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>> compressedUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>>();
-            OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();
-            OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseAgentUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();
-
             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>>();
 
-//            objectUpdateBlocks.Value.Clear();
-//            compressedUpdateBlocks.Value.Clear();
-//            terseUpdateBlocks.Value.Clear();
-//            terseAgentUpdateBlocks.Value.Clear();
-//            objectUpdates.Value.Clear();
-//            compressedUpdates.Value.Clear();
-//            terseUpdates.Value.Clear();
-//            terseAgentUpdates.Value.Clear();
-
             // Check to see if this is a flush
-            if (maxUpdates <= 0)
+            if (maxUpdatesBytes <= 0)
             {
-                maxUpdates = Int32.MaxValue;
+                maxUpdatesBytes = Int32.MaxValue;
             }
 
-            int updatesThisCall = 0;
+            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;
 
-            // We must lock for both manipulating the kill record and sending the packet, in order to avoid a race
-            // condition where a kill can be processed before an out-of-date update for the same object.                        
-            lock (m_killRecord)
+            if(doCulling)
             {
-                float avgTimeDilation = 1.0f;
-                IEntityUpdate iupdate;
-                Int32 timeinqueue; // this is just debugging code & can be dropped later
+                cullingrange = mysp.DrawDistance + m_scene.ReprioritizationDistance + 16f;
+//                mycamera = mysp.CameraPosition;
+                mypos = mysp.AbsolutePosition;
+            }
 
-                while (updatesThisCall < maxUpdates)
+            while (maxUpdatesBytes > 0)
+            {
+                lock (m_entityUpdates.SyncRoot)
                 {
-                    lock (m_entityUpdates.SyncRoot)
-                        if (!m_entityUpdates.TryDequeue(out iupdate, out timeinqueue))
+                    if(orderedDequeue)
+                    {
+                        if (!m_entityUpdates.TryOrderedDequeue(out update, out timeinqueue))
                             break;
+                    }
+                    else
+                    {
+                        if (!m_entityUpdates.TryDequeue(out update, out timeinqueue))
+                            break;
+                    }
+                }
 
-                    EntityUpdate update = (EntityUpdate)iupdate;
-                    
-                    avgTimeDilation += update.TimeDilation;
-                    avgTimeDilation *= 0.5f;
+                PrimUpdateFlags updateFlags = (PrimUpdateFlags)update.Flags;
 
-                    if (update.Entity is SceneObjectPart)
+                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)
                     {
-                        SceneObjectPart part = (SceneObjectPart)update.Entity;
-    
-                        // Please do not remove this unless you can demonstrate on the OpenSim mailing list that a client
-                        // will never receive an update after a prim kill.  Even then, keeping the kill record may be a good
-                        // safety measure.
-                        //
-                        // If a Linden Lab 1.23.5 client (and possibly later and earlier) receives an object update
-                        // after a kill, it will keep displaying the deleted object until relog.  OpenSim currently performs
-                        // updates and kills on different threads with different scheduling strategies, hence this protection.
-                        // 
-                        // This doesn't appear to apply to child prims - a client will happily ignore these updates
-                        // after the root prim has been deleted.
-                        if (m_killRecord.Contains(part.LocalId))
+                        // 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_log.WarnFormat(
-        //                            "[CLIENT]: Preventing update for prim with local id {0} after client for user {1} told it was deleted",
-        //                            part.LocalId, Name);
+                            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;
-                        }                        
-                            
-                        if (part.ParentGroup.IsAttachment && m_disableFacelights)
+
+                        List<SceneObjectGroup> atts = sp.GetAttachments();
+                        bool found = false;
+                        foreach (SceneObjectGroup att in atts)
                         {
-                            if (part.ParentGroup.RootPart.Shape.State != (byte)AttachmentPoint.LeftHand &&
-                                part.ParentGroup.RootPart.Shape.State != (byte)AttachmentPoint.RightHand)
+                            if (att == grp)
                             {
-                                part.Shape.LightEntry = false;
+                                found = true;
+                                break;
                             }
                         }
 
-                        if (part.Shape != null && (part.Shape.SculptType == (byte)SculptType.Mesh))
-                        {
-                            // Ensure that mesh has at least 8 valid faces
-                            part.Shape.ProfileBegin = 12500;
-                            part.Shape.ProfileEnd = 0;
-                            part.Shape.ProfileHollow = 27500;
-                        }
-                    }
-    
-                    #region UpdateFlags to packet type conversion
-    
-                    PrimUpdateFlags updateFlags = (PrimUpdateFlags)update.Flags;
-    
-                    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;
+                        // 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;
+
                     }
-                    else
+
+                    if (grp.IsAttachment && m_disableFacelights)
                     {
-                        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))
+                        if (grp.RootPart.Shape.State != (byte)AttachmentPoint.LeftHand &&
+                            grp.RootPart.Shape.State != (byte)AttachmentPoint.RightHand)
                         {
-                            canUseImproved = false;
+                            part.Shape.LightEntry = false;
                         }
                     }
-    
-                    #endregion UpdateFlags to packet type conversion
-    
-                    #region Block Construction
-    
-                    // TODO: Remove this once we can build compressed updates
-                    canUseCompressed = false;
-    
-                    if (!canUseImproved && !canUseCompressed)
+
+                    if(doCulling && !grp.IsAttachment)
                     {
-                        ObjectUpdatePacket.ObjectDataBlock updateBlock;
+                        if(GroupsNeedFullUpdate.Contains(grp))
+                            continue;
 
-                        if (update.Entity is ScenePresence)
-                        {
-                            updateBlock = CreateAvatarUpdateBlock((ScenePresence)update.Entity);
-                        }
-                        else
+                        bool inview = false;
+                        lock(GroupsInView)
+                            inview = GroupsInView.Contains(grp);
+
+                        if(!inview)
                         {
-                            SceneObjectPart part = (SceneObjectPart)update.Entity;
-                            updateBlock = CreatePrimUpdateBlock(part, AgentId);
-
-                            // If the part has become a private hud since the update was scheduled then we do not
-                            // want to send it to other avatars.
-                            if (part.ParentGroup.IsAttachment
-                                && part.ParentGroup.HasPrivateAttachmentPoint
-                                && part.ParentGroup.AttachedAvatar != AgentId)
+                            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;
 
-                            // If the part has since been deleted, then drop the update.  In the case of attachments,
-                            // this is to avoid spurious updates to other viewers since post-processing of attachments
-                            // has to change the IsAttachment flag for various reasons (which will end up in a pass
-                            // of the test above).
-                            //
-                            // Actual deletions (kills) happen in another method.
-                            if (part.ParentGroup.IsDeleted)
-                                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;
+                }
 
-                        objectUpdateBlocks.Value.Add(updateBlock);
-                        objectUpdates.Value.Add(update);
+                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;
                     }
-                    else if (!canUseImproved)
+
+                    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))
                     {
-                        SceneObjectPart part = (SceneObjectPart)update.Entity;
-                        ObjectUpdateCompressedPacket.ObjectDataBlock compressedBlock
-                            = CreateCompressedUpdateBlock(part, updateFlags);
-
-                        // If the part has since been deleted, then drop the update.  In the case of attachments,
-                        // this is to avoid spurious updates to other viewers since post-processing of attachments
-                        // has to change the IsAttachment flag for various reasons (which will end up in a pass
-                        // of the test above).
-                        //
-                        // Actual deletions (kills) happen in another method.
-                        if (part.ParentGroup.IsDeleted)
-                            continue;
+                        canUseImproved = false;
+                    }
+                }
+
+                #endregion UpdateFlags to packet type conversion
 
-                        compressedUpdateBlocks.Value.Add(compressedBlock);
-                        compressedUpdates.Value.Add(update);
+                #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
                     {
-                        if (update.Entity is ScenePresence && ((ScenePresence)update.Entity).UUID == AgentId)
-                        {
-                            // Self updates go into a special list
-                            terseAgentUpdateBlocks.Value.Add(CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures)));
-                            terseAgentUpdates.Value.Add(update);
-                        }
-                        else
-                        {
-                            ImprovedTerseObjectUpdatePacket.ObjectDataBlock terseUpdateBlock
-                                = CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures));
+                        // Everything else goes here
+                        ablock = CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures));
+                        terseUpdateBlocks.Add(ablock);
+                        terseUpdates.Value.Add(update);
+                    }
+                    maxUpdatesBytes -= ablock.Length;
+                }
 
-                            // Everything else goes here
-                            if (update.Entity is SceneObjectPart)
-                            {
-                                SceneObjectPart part = (SceneObjectPart)update.Entity;
-
-                                // If the part has become a private hud since the update was scheduled then we do not
-                                // want to send it to other avatars.
-                                if (part.ParentGroup.IsAttachment
-                                    && part.ParentGroup.HasPrivateAttachmentPoint
-                                    && part.ParentGroup.AttachedAvatar != AgentId)
-                                    continue;
-
-                                // If the part has since been deleted, then drop the update.  In the case of attachments,
-                                // this is to avoid spurious updates to other viewers since post-processing of attachments
-                                // has to change the IsAttachment flag for various reasons (which will end up in a pass
-                                // of the test above).
-                                //
-                                // Actual deletions (kills) happen in another method.
-                                if (part.ParentGroup.IsDeleted)
-                                    continue;
-                            }
+                #endregion Block Construction
+            }
 
-                            terseUpdateBlocks.Value.Add(terseUpdateBlock);
-                            terseUpdates.Value.Add(update);
-                        }
-                    }
+            #region Packet Sending
 
-                    ++updatesThisCall;
-    
-                    #endregion Block Construction
-                }
-    
-                #region Packet Sending
-                ushort timeDilation = Utils.FloatToUInt16(avgTimeDilation, 0.0f, 1.0f);
+            ushort timeDilation;
 
-                if (terseAgentUpdateBlocks.IsValueCreated)
-                {
-                    List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> blocks = terseAgentUpdateBlocks.Value;
+            if(!IsActive)
+                return;
+
+            timeDilation = Utils.FloatToUInt16(m_scene.TimeDilation, 0.0f, 1.0f);
 
-                    ImprovedTerseObjectUpdatePacket packet
-                        = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate);
+            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];
 
-                    packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
-                    packet.RegionData.TimeDilation = timeDilation;
-                    packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[blocks.Count];
+                for (int i = 0; i < terseAgentUpdateBlocks.Count; i++)
+                    packet.ObjectData[i] = terseAgentUpdateBlocks[i];
 
-                    for (int i = 0; i < blocks.Count; i++)
-                        packet.ObjectData[i] = blocks[i];
-                    // If any of the packets created from this call go unacknowledged, all of the updates will be resent
-                    OutPacket(packet, ThrottleOutPacketType.Unknown, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseAgentUpdates.Value, oPacket); });
-                }
+                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();
 
-                if (objectUpdateBlocks.IsValueCreated)
+                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)
                 {
-                    List<ObjectUpdatePacket.ObjectDataBlock> blocks = objectUpdateBlocks.Value;
-        
-                    ObjectUpdatePacket packet = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);
-                    packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
-                    packet.RegionData.TimeDilation = timeDilation;
-                    packet.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[blocks.Count];
-        
-                    for (int i = 0; i < blocks.Count; i++)
-                        packet.ObjectData[i] = blocks[i];
-                    // If any of the packets created from this call go unacknowledged, all of the updates will be resent
-                    OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(objectUpdates.Value, oPacket); });
+                    foreach(SceneObjectPart p in grp.Parts)
+                        SendEntityUpdate(p,PrimUpdateFlags.CancelKill);
+                    lock(GroupsInView)
+                        GroupsInView.Add(grp);
                 }
-        
-                if (compressedUpdateBlocks.IsValueCreated)
+            }
+            #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)
                 {
-                    List<ObjectUpdateCompressedPacket.ObjectDataBlock> blocks = compressedUpdateBlocks.Value;
-        
-                    ObjectUpdateCompressedPacket packet = (ObjectUpdateCompressedPacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdateCompressed);
-                    packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
-                    packet.RegionData.TimeDilation = timeDilation;
-                    packet.ObjectData = new ObjectUpdateCompressedPacket.ObjectDataBlock[blocks.Count];
-        
-                    for (int i = 0; i < blocks.Count; i++)
-                        packet.ObjectData[i] = blocks[i];
-                    // If any of the packets created from this call go unacknowledged, all of the updates will be resent
-                    OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(compressedUpdates.Value, oPacket); });
+                    blk.ParentID = parentID.Value;
                 }
 
-                if (terseUpdateBlocks.IsValueCreated)
-                {
-                    List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> blocks = terseUpdateBlocks.Value;
-        
-                    ImprovedTerseObjectUpdatePacket packet
-                        = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(
-                            PacketType.ImprovedTerseObjectUpdate);
+                packet.ObjectData[0] = blk;
 
-                    packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
-                    packet.RegionData.TimeDilation = timeDilation;
-                    packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[blocks.Count];
-        
-                    for (int i = 0; i < blocks.Count; i++)
-                        packet.ObjectData[i] = blocks[i];
-                    // If any of the packets created from this call go unacknowledged, all of the updates will be resent
-                    OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseUpdates.Value, oPacket); });
-                }
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
             }
 
 //            m_log.DebugFormat(
-//                "[LLCLIENTVIEW]: Sent {0} updates in ProcessEntityUpdates() for {1} {2} in {3}", 
+//                "[LLCLIENTVIEW]: Sent {0} updates in ProcessEntityUpdates() for {1} {2} in {3}",
 //                updatesThisCall, Name, SceneAgent.IsChildAgent ? "child" : "root", Scene.Name);
 //
-            #endregion Packet Sending
         }
-
+*/
         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)
@@ -4285,63 +4673,46 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         // 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;
+//        private Int32 m_LastQueueFill = 0;
+//        private Int32 m_maxUpdates = 0;
 
         void HandleQueueEmpty(ThrottleOutPacketTypeFlags categories)
         {
-//            if (!m_udpServer.IsRunningOutbound)
-//                return;
+            if(m_scene == null)
+                return;
 
             if ((categories & ThrottleOutPacketTypeFlags.Task) != 0)
             {
-//                if (!m_udpServer.IsRunningOutbound)
-//                    return;
+                int maxUpdateBytes = m_udpClient.GetCatBytesCanSend(ThrottleOutPacketType.Task, 30);
 
-                if (m_maxUpdates == 0 || m_LastQueueFill == 0)
-                {
-                    m_maxUpdates = m_udpServer.PrimUpdatesPerCallback;
-                }
-                else
-                {
-                    if (Util.EnvironmentTickCountSubtract(m_LastQueueFill) < 200)
-                        m_maxUpdates += 5;
-                    else
-                        m_maxUpdates = m_maxUpdates >> 1;
-                }
-                m_maxUpdates = Util.Clamp<Int32>(m_maxUpdates,10,500);
-                m_LastQueueFill = Util.EnvironmentTickCount();
-            
                 if (m_entityUpdates.Count > 0)
-                    ProcessEntityUpdates(m_maxUpdates);
+                    ProcessEntityUpdates(maxUpdateBytes);
 
                 if (m_entityProps.Count > 0)
-                    ProcessEntityPropertyRequests(m_maxUpdates);
+                    ProcessEntityPropertyRequests(maxUpdateBytes);
             }
 
             if ((categories & ThrottleOutPacketTypeFlags.Texture) != 0)
                 ImageManager.ProcessImageQueue(m_udpServer.TextureSendLimit);
-        }
+    }
 
         internal bool HandleHasUpdates(ThrottleOutPacketTypeFlags categories)
         {
-            bool hasUpdates = false;
-
             if ((categories & ThrottleOutPacketTypeFlags.Task) != 0)
             {
                 if (m_entityUpdates.Count > 0)
-                    hasUpdates = true;
-                else if (m_entityProps.Count > 0)
-                    hasUpdates = true;                   
+                    return true;
+                if (m_entityProps.Count > 0)
+                    return true;
             }
 
             if ((categories & ThrottleOutPacketTypeFlags.Texture) != 0)
             {
                 if (ImageManager.HasUpdates())
-                    hasUpdates = true;
+                    return true;
             }
 
-            return hasUpdates;
+            return false;
         }
 
         public void SendAssetUploadCompleteMessage(sbyte AssetType, bool Success, UUID AssetFullID)
@@ -4443,13 +4814,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(pack, ThrottleOutPacketType.Task);
         }
 
-        private class ObjectPropertyUpdate : IEntityUpdate
+        private class ObjectPropertyUpdate : EntityUpdate
         {
             internal bool SendFamilyProps;
             internal bool SendObjectProps;
-            
+
             public ObjectPropertyUpdate(ISceneEntity entity, uint flags, bool sendfam, bool sendobj)
-                : base(entity,flags)
+                : base(entity,(PrimUpdateFlags)flags)
             {
                 SendFamilyProps = sendfam;
                 SendObjectProps = sendobj;
@@ -4462,7 +4833,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 base.Update(update);
             }
         }
-        
+
         public void SendObjectPropertiesFamilyData(ISceneEntity entity, uint requestFlags)
         {
             uint priority = 0;  // time based ordering only
@@ -4496,7 +4867,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             foreach (ObjectPropertyUpdate update in updates)
                 ResendPropertyUpdate(update);
         }
-        
+
         public void SendObjectPropertiesReply(ISceneEntity entity)
         {
             uint priority = 0;  // time based ordering only
@@ -4504,29 +4875,40 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_entityProps.Enqueue(priority, new ObjectPropertyUpdate(entity,0,false,true));
         }
 
-        private void ProcessEntityPropertyRequests(int maxUpdates)
+       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<ObjectPropertiesFamilyPacket.ObjectDataBlock>> objectFamilyBlocks =
-                new OpenSim.Framework.Lazy<List<ObjectPropertiesFamilyPacket.ObjectDataBlock>>();
+//            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> familyUpdates =
+//                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
 
-            OpenSim.Framework.Lazy<List<ObjectPropertiesPacket.ObjectDataBlock>> objectPropertiesBlocks =
-                new OpenSim.Framework.Lazy<List<ObjectPropertiesPacket.ObjectDataBlock>>();
+//            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> propertyUpdates =
+//                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
 
-            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> familyUpdates =
-                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
+            bool orderedDequeue = m_scene.UpdatePrioritizationScheme  == UpdatePrioritizationSchemes.SimpleAngularDistance;
 
-            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> propertyUpdates =
-                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
-            
-            IEntityUpdate iupdate;
+            EntityUpdate iupdate;
             Int32 timeinqueue; // this is just debugging code & can be dropped later
 
-            int updatesThisCall = 0;
-            while (updatesThisCall < m_maxUpdates)
+            while (maxUpdateBytes > 0)
             {
                 lock (m_entityProps.SyncRoot)
-                    if (!m_entityProps.TryDequeue(out iupdate, out timeinqueue))
-                        break;
+                {
+                    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)
@@ -4535,8 +4917,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     {
                         SceneObjectPart sop = (SceneObjectPart)update.Entity;
                         ObjectPropertiesFamilyPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesFamilyBlock(sop,update.Flags);
-                        objectFamilyBlocks.Value.Add(objPropDB);
-                        familyUpdates.Value.Add(update);
+                        objectFamilyBlocks.Add(objPropDB);
+//                        familyUpdates.Value.Add(update);
+                        maxUpdateBytes -= objPropDB.Length;
                     }
                 }
 
@@ -4545,84 +4928,107 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     if (update.Entity is SceneObjectPart)
                     {
                         SceneObjectPart sop = (SceneObjectPart)update.Entity;
+                        needPhysics.Add(sop);
                         ObjectPropertiesPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesBlock(sop);
-                        objectPropertiesBlocks.Value.Add(objPropDB);
-                        propertyUpdates.Value.Add(update);
+                        objectPropertiesBlocks.Add(objPropDB);
+//                        propertyUpdates.Value.Add(update);
+                        maxUpdateBytes -= objPropDB.Length;
                     }
                 }
-
-                updatesThisCall++;
             }
-            
 
-            // Int32 ppcnt = 0;
-            // Int32 pbcnt = 0;
-            
-            if (objectPropertiesBlocks.IsValueCreated)
+            if (objectPropertiesBlocks.Count > 0)
             {
-                List<ObjectPropertiesPacket.ObjectDataBlock> blocks = objectPropertiesBlocks.Value;
-                List<ObjectPropertyUpdate> updates = propertyUpdates.Value;
-
                 ObjectPropertiesPacket packet = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
-                packet.ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[blocks.Count];
-                for (int i = 0; i < blocks.Count; i++)
-                    packet.ObjectData[i] = blocks[i];
+                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
-                OutPacket(packet, ThrottleOutPacketType.Task, true,
-                          delegate(OutgoingPacket oPacket)
-                          {
-                              ResendPropertyUpdates(updates, oPacket);
-                          });
+                // 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.IsValueCreated)
+
+            if (objectFamilyBlocks.Count > 0)
             {
-                List<ObjectPropertiesFamilyPacket.ObjectDataBlock> blocks = objectFamilyBlocks.Value;
-                
                 // one packet per object block... uggh...
-                for (int i = 0; i < blocks.Count; i++)
+                for (int i = 0; i < objectFamilyBlocks.Count; i++)
                 {
                     ObjectPropertiesFamilyPacket packet =
                         (ObjectPropertiesFamilyPacket)PacketPool.Instance.GetPacket(PacketType.ObjectPropertiesFamily);
 
-                    packet.ObjectData = blocks[i];
+                    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]);
-                    OutPacket(packet, ThrottleOutPacketType.Task, true,
-                              delegate(OutgoingPacket oPacket)
-                              {
-                                  ResendPropertyUpdates(updates, oPacket);
-                              });
+//                    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, uint requestFlags)
+        private ObjectPropertiesFamilyPacket.ObjectDataBlock CreateObjectPropertiesFamilyBlock(SceneObjectPart sop, PrimUpdateFlags requestFlags)
         {
             ObjectPropertiesFamilyPacket.ObjectDataBlock block = new ObjectPropertiesFamilyPacket.ObjectDataBlock();
 
-            block.RequestFlags = requestFlags;
+            block.RequestFlags = (uint)requestFlags;
             block.ObjectID = sop.UUID;
             if (sop.OwnerID == sop.GroupID)
                 block.OwnerID = UUID.Zero;
@@ -4640,13 +5046,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             block.SaleType = sop.ObjectSaleType;
             block.SalePrice = sop.SalePrice;
             block.Category = sop.Category;
-            block.LastOwnerID = sop.CreatorID; // copied from old SOG call... is this right?
+            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);
@@ -4672,7 +5078,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);
@@ -4684,7 +5090,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 //            {
 //                using (BinaryWriter binWriter = new BinaryWriter(memStream))
 //                {
-//                    for (int i = 0; i < sop.GetNumberOfSides(); i++)               
+//                    for (int i = 0; i < sop.GetNumberOfSides(); i++)
 //                    {
 //                        Primitive.TextureEntryFace teFace = sop.Shape.Textures.FaceTextures[i];
 //
@@ -4701,7 +5107,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 //                    block.TextureID = memStream.ToArray();
 //                }
 //            }
-           
+
             block.TextureID = new byte[0]; // TextureID ???
             block.SitName = Util.StringToBytes256(root.SitName);
             block.OwnerMask = root.OwnerMask;
@@ -4728,52 +5134,74 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         }
 
         public void SendEstateList(UUID invoice, int code, UUID[] Data, uint estateID)
-
         {
-            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");
+            int TotalnumberIDs = Data.Length;
+            int numberIDs;
+            int IDIndex = 0;
 
-            EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[6 + Data.Length];
-
-            for (int i = 0; i < (6 + Data.Length); i++)
+            do
             {
-                returnblock[i] = new EstateOwnerMessagePacket.ParamListBlock();
-            }
-            int j = 0;
+                if(TotalnumberIDs > 63)
+                    numberIDs = 63;
+                else
+                    numberIDs = TotalnumberIDs;
 
-            returnblock[j].Parameter = Utils.StringToBytes(estateID.ToString()); j++;
-            returnblock[j].Parameter = Utils.StringToBytes(code.ToString()); j++;
-            returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
-            returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
-            returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
-            returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
+                TotalnumberIDs -= numberIDs;
 
-            j = 2; // Agents
-            if ((code & 2) != 0)
-                j = 3; // Groups
-            if ((code & 8) != 0)
-                j = 5; // Managers
+                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");
 
-            returnblock[j].Parameter = Utils.StringToBytes(Data.Length.ToString());
-            j = 6;
+                EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[6 + numberIDs];
 
-            for (int i = 0; i < Data.Length; i++)
-            {
-                returnblock[j].Parameter = Data[i].GetBytes(); j++;
-            }
-            packet.ParamList = returnblock;
-            packet.Header.Reliable = true;
-            OutPacket(packet, ThrottleOutPacketType.Task);
+                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)
@@ -4781,44 +5209,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 if (bl[i].BannedUserID == UUID.Zero)
                     continue;
                 BannedUsers.Add(bl[i].BannedUserID);
-
-                if (BannedUsers.Count >= 50 || (i == (bl.Length - 1) && BannedUsers.Count > 0))
-                {
-                    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 + BannedUsers.Count];
-
-                    int j;
-                    for (j = 0; j < (6 + BannedUsers.Count); j++)
-                    {
-                        returnblock[j] = new EstateOwnerMessagePacket.ParamListBlock();
-                    }
-                    j = 0; 
-
-                    returnblock[j].Parameter = Utils.StringToBytes(estateID.ToString()); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes(((int)Constants.EstateAccessCodex.EstateBans).ToString()); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes(BannedUsers.Count.ToString()); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
-
-                    foreach (UUID banned in BannedUsers)
-                    {
-                        returnblock[j].Parameter = banned.GetBytes(); j++;
-                    }
-                    packet.ParamList = returnblock;
-                    packet.Header.Reliable = true;
-                    OutPacket(packet, ThrottleOutPacketType.Task);
-
-                    BannedUsers.Clear();
-                }
             }
-
+            SendEstateList(invoice, 4, BannedUsers.ToArray(), estateID);
         }
 
         public void SendRegionInfoToEstateMenu(RegionInfoForEstateMenuArgs args)
@@ -4864,7 +5256,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         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;
@@ -4881,7 +5273,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
 //            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();
@@ -4939,17 +5331,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             packet.ParcelData.Data = data;
             packet.ParcelData.SequenceID = sequence_id;
             packet.Header.Zerocoded = true;
-            OutPacket(packet, ThrottleOutPacketType.Task);
+//            OutPacket(packet, ThrottleOutPacketType.Task);
+            OutPacket(packet, ThrottleOutPacketType.Land);
         }
 
         public void SendLandProperties(
-             int sequence_id, bool snap_selection, int request_result, ILandObject lo, 
+             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;
@@ -4962,7 +5355,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             updateMessage.Category = landData.Category;
             updateMessage.ClaimDate = Util.ToDateTime(landData.ClaimDate);
             updateMessage.ClaimPrice = landData.ClaimPrice;
-            updateMessage.GroupID = landData.GroupID;            
+            updateMessage.GroupID = landData.GroupID;
             updateMessage.IsGroupOwned = landData.IsGroupOwned;
             updateMessage.LandingType = (LandingType) landData.LandingType;
             updateMessage.LocalID = landData.LocalID;
@@ -4983,7 +5376,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             updateMessage.Name = landData.Name;
             updateMessage.OtherCleanTime = landData.OtherCleanTime;
             updateMessage.OtherCount = 0; //TODO: Unimplemented
-            updateMessage.OwnerID = landData.OwnerID;            
+            updateMessage.OwnerID = landData.OwnerID;
             updateMessage.ParcelFlags = (ParcelFlags) landData.Flags;
             updateMessage.ParcelPrimBonus = simObjectBonusFactor;
             updateMessage.PassHours = landData.PassHours;
@@ -4998,20 +5391,19 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             updateMessage.RentPrice = 0;
             updateMessage.RequestResult = (ParcelResult) request_result;
-            updateMessage.SalePrice = landData.SalePrice;            
+            updateMessage.SalePrice = landData.SalePrice;
             updateMessage.SelfCount = 0; //TODO: Unimplemented
             updateMessage.SequenceID = sequence_id;
-            
+
             if (landData.SimwideArea > 0)
             {
-                int simulatorCapacity = (int)(((float)landData.SimwideArea / 65536.0f) * (float)m_scene.RegionInfo.ObjectCapacity * (float)m_scene.RegionInfo.RegionSettings.ObjectBonus);
-                updateMessage.SimWideMaxPrims = simulatorCapacity;
+                updateMessage.SimWideMaxPrims = lo.GetSimulatorMaxPrimCount();
             }
             else
             {
                 updateMessage.SimWideMaxPrims = 0;
             }
-            
+
             updateMessage.SnapSelection = snap_selection;
             updateMessage.SnapshotID    = landData.SnapshotID;
             updateMessage.Status        = (ParcelStatus) landData.Status;
@@ -5025,23 +5417,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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.OwnerPrims        = pc.Owner;
             updateMessage.GroupPrims        = pc.Group;
-            updateMessage.OtherPrims        = pc.Others;            
+            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 
+                }
+                else
                 {
                     m_log.Warn("[LLCLIENTVIEW]: No EQ Interface when sending parcel data.");
                 }
@@ -5078,7 +5476,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         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);
@@ -5133,14 +5531,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             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;
-                }
+//                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];
@@ -5178,6 +5576,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         #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)
         {
@@ -5191,45 +5609,33 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             Quaternion rotation;
             byte[] textureEntry;
 
-            if (entity is ScenePresence)
+            if (avatar)
             {
                 ScenePresence presence = (ScenePresence)entity;
 
-//                m_log.DebugFormat( 
-//                    "[LLCLIENTVIEW]: Sending terse update to {0} with pos {1}, vel {2} in {3}", 
-//                    Name, presence.OffsetPosition, presence.Velocity, m_scene.Name);
-
-                attachPoint = presence.State;
-                collisionPlane = presence.CollisionPlane;
                 position = presence.OffsetPosition;
                 velocity = presence.Velocity;
                 acceleration = Vector3.Zero;
-
-                // Interestingly, sending this to non-zero will cause the client's avatar to start moving & accelerating
-                // in that direction, even though we don't model this on the server.  Implementing this in the future
-                // may improve movement smoothness.
-//                acceleration = new Vector3(1, 0, 0);
-                
-                angularVelocity = presence.AngularVelocity;
-
-                // Whilst not in mouselook, an avatar will transmit only the Z rotation as this is the only axis
-                // it rotates around.
-                // In mouselook, X and Y co-ordinate will also be sent but when used in Rotation, these cause unwanted
-                // excessive up and down movements of the camera when looking up and down.
-                // See http://opensimulator.org/mantis/view.php?id=3274
-                // This does not affect head movement, since this is controlled entirely by camera movement rather than
-                // body rotation.  We still need to transmit X and Y for sitting avatars but mouselook does not change
-                // the rotation in this case.
                 rotation = presence.Rotation;
-
-                if (!presence.IsSatOnObject)
+                // tpvs can only see rotations around Z in some cases
+                if(!presence.Flying && !presence.IsSatOnObject)
                 {
-                    rotation.X = 0;
-                    rotation.Y = 0;
+                    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;
             }
@@ -5287,11 +5693,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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;
@@ -5303,13 +5711,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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)
@@ -5333,34 +5742,31 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         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];
 
-            data.CollisionPlane.ToBytes(objectData, 0);
-            data.OffsetPosition.ToBytes(objectData, 16);
-            data.Velocity.ToBytes(objectData, 28);
-//            data.Acceleration.ToBytes(objectData, 40);
-
-            // Whilst not in mouselook, an avatar will transmit only the Z rotation as this is the only axis
-            // it rotates around.
-            // In mouselook, X and Y co-ordinate will also be sent but when used in Rotation, these cause unwanted
-            // excessive up and down movements of the camera when looking up and down.
-            // See http://opensimulator.org/mantis/view.php?id=3274
-            // This does not affect head movement, since this is controlled entirely by camera movement rather than
-            // body rotation.  We still need to transmit X and Y for sitting avatars but mouselook does not change
-            // the rotation in this case.
-            Quaternion rot = data.Rotation;
-
-            if (!data.IsSatOnObject)
+            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)
             {
-                rot.X = 0;
-                rot.Y = 0;
+                rotation.X = 0f;
+                rotation.Y = 0f;
             }
+            rotation.Normalize();
 
-            rot.ToBytes(objectData, 52);
-            //data.AngularVelocity.ToBytes(objectData, 64);
+            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();
 
@@ -5386,7 +5792,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             update.PCode = (byte)PCode.Avatar;
             update.ProfileCurve = 1;
             update.PSBlock = Utils.EmptyBytes;
-            update.Scale = new Vector3(0.45f, 0.6f, 1.9f);
+            update.Scale = data.Appearance.AvatarSize;
+//            update.Scale.Z -= 0.2f;
+
             update.Text = Utils.EmptyBytes;
             update.TextColor = new byte[4];
 
@@ -5397,46 +5805,44 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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 data, UUID recipientID)
+        protected ObjectUpdatePacket.ObjectDataBlock CreatePrimUpdateBlock(SceneObjectPart part, ScenePresence sp)
         {
             byte[] objectData = new byte[60];
-            data.RelativePosition.ToBytes(objectData, 0);
-            data.Velocity.ToBytes(objectData, 12);
-            data.Acceleration.ToBytes(objectData, 24);
-            try
-            {
-                data.RotationOffset.ToBytes(objectData, 36);
-            }
-            catch (Exception e)
-            {
-                m_log.Warn("[LLClientView]: exception converting quaternion to bytes, using Quaternion.Identity. Exception: " + e.ToString());
-                OpenMetaverse.Quaternion.Identity.ToBytes(objectData, 36);
-            }
-            data.AngularVelocity.ToBytes(objectData, 48);
+            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)data.ClickAction;
+            update.ClickAction = (byte)part.ClickAction;
             update.CRC = 0;
-            update.ExtraParams = data.Shape.ExtraParams ?? Utils.EmptyBytes;
-            update.FullID = data.UUID;
-            update.ID = data.LocalId;
+            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 = data.Material;
-            update.MediaURL = Utils.EmptyBytes; // FIXME: Support this in OpenSim
-
+            update.Material = part.Material;
+/*
             if (data.ParentGroup.IsAttachment)
             {
-                update.NameValue 
+                update.NameValue
                     = Util.StringToBytes256(
                         string.Format("AttachItemID STRING RW SV {0}", data.ParentGroup.FromItemID));
 
@@ -5458,50 +5864,91 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 // 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 = data.ParentID;
-            update.PathBegin = data.Shape.PathBegin;
-            update.PathCurve = data.Shape.PathCurve;
-            update.PathEnd = data.Shape.PathEnd;
-            update.PathRadiusOffset = data.Shape.PathRadiusOffset;
-            update.PathRevolutions = data.Shape.PathRevolutions;
-            update.PathScaleX = data.Shape.PathScaleX;
-            update.PathScaleY = data.Shape.PathScaleY;
-            update.PathShearX = data.Shape.PathShearX;
-            update.PathShearY = data.Shape.PathShearY;
-            update.PathSkew = data.Shape.PathSkew;
-            update.PathTaperX = data.Shape.PathTaperX;
-            update.PathTaperY = data.Shape.PathTaperY;
-            update.PathTwist = data.Shape.PathTwist;
-            update.PathTwistBegin = data.Shape.PathTwistBegin;
-            update.PCode = data.Shape.PCode;
-            update.ProfileBegin = data.Shape.ProfileBegin;
-            update.ProfileCurve = data.Shape.ProfileCurve;
-            update.ProfileEnd = data.Shape.ProfileEnd;
-            update.ProfileHollow = data.Shape.ProfileHollow;
-            update.PSBlock = data.ParticleSystem ?? Utils.EmptyBytes;
-            update.TextColor = data.GetTextColor().GetBytes(false);
-            update.TextureAnim = data.TextureAnimation ?? Utils.EmptyBytes;
-            update.TextureEntry = data.Shape.TextureEntry ?? Utils.EmptyBytes;
-            update.Scale = data.Shape.Scale;
-            update.Text = Util.StringToBytes256(data.Text);
-            update.MediaURL = Util.StringToBytes256(data.MediaUrl);
+            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(recipientID, data.UUID);
+            PrimFlags flags = (PrimFlags)m_scene.Permissions.GenerateClientFlags(part, sp);
 
             // Don't send the CreateSelected flag to everyone
             flags &= ~PrimFlags.CreateSelected;
 
-            if (recipientID == data.OwnerID)
+            if (sp.UUID == part.OwnerID)
             {
-                if (data.CreateSelected)
+                if (part.CreateSelected)
                 {
                     // Only send this flag once, then unset it
                     flags |= PrimFlags.CreateSelected;
-                    data.CreateSelected = false;
+                    part.CreateSelected = false;
                 }
             }
 
@@ -5513,21 +5960,21 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             #endregion PrimFlags
 
-            if (data.Sound != UUID.Zero)
+            if (part.Sound != UUID.Zero)
             {
-                update.Sound = data.Sound;
-                update.OwnerID = data.OwnerID;
-                update.Gain = (float)data.SoundGain;
-                update.Radius = (float)data.SoundRadius;
-                update.Flags = data.SoundFlags;
+                update.Sound = part.Sound;
+                update.OwnerID = part.OwnerID;
+                update.Gain = (float)part.SoundGain;
+                update.Radius = (float)part.SoundRadius;
+                update.Flags = part.SoundFlags;
             }
 
-            switch ((PCode)data.Shape.PCode)
+            switch ((PCode)part.Shape.PCode)
             {
                 case PCode.Grass:
                 case PCode.Tree:
                 case PCode.NewTree:
-                    update.Data = new byte[] { data.Shape.State };
+                    update.Data = new byte[] { part.Shape.State };
                     break;
                 default:
                     update.Data = Utils.EmptyBytes;
@@ -5556,14 +6003,30 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(packet, ThrottleOutPacketType.Task);
         }
 
-        public ulong GetGroupPowers(UUID groupID)
+        public Dictionary<UUID, ulong> GetGroupPowers()
         {
-            if (groupID == ActiveGroupId)
-                return ActiveGroupPowers;
+            lock(m_groupPowers)
+            {
+                return new Dictionary<UUID, ulong>(m_groupPowers);
+            }
+        }
 
-            if (m_groupPowers.ContainsKey(groupID))
-                return m_groupPowers[groupID];
+        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;
         }
 
@@ -5579,18 +6042,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // 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, true, true);
-            AddLocalPacketHandler(PacketType.AvatarPropertiesRequest, HandleAvatarPropertiesRequest, true, true);
+            AddLocalPacketHandler(PacketType.GenericMessage, HandleGenericMessage);
+            AddLocalPacketHandler(PacketType.AvatarPropertiesRequest, HandleAvatarPropertiesRequest);
             AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);
-            AddLocalPacketHandler(PacketType.AvatarPropertiesUpdate, HandlerAvatarPropertiesUpdate, true, true);
+            AddLocalPacketHandler(PacketType.AvatarPropertiesUpdate, HandlerAvatarPropertiesUpdate);
             AddLocalPacketHandler(PacketType.ScriptDialogReply, HandlerScriptDialogReply);
             AddLocalPacketHandler(PacketType.ImprovedInstantMessage, HandlerImprovedInstantMessage);
             AddLocalPacketHandler(PacketType.AcceptFriendship, HandlerAcceptFriendship);
@@ -5598,6 +6063,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);
@@ -5732,6 +6198,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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);
@@ -5775,8 +6242,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.PickDelete, HandlePickDelete);
             AddLocalPacketHandler(PacketType.PickGodDelete, HandlePickGodDelete);
             AddLocalPacketHandler(PacketType.PickInfoUpdate, HandlePickInfoUpdate);
-            AddLocalPacketHandler(PacketType.AvatarNotesUpdate, HandleAvatarNotesUpdate, true, true);
-            AddLocalPacketHandler(PacketType.AvatarInterestsUpdate, HandleAvatarInterestsUpdate, true, true);
+            AddLocalPacketHandler(PacketType.AvatarNotesUpdate, HandleAvatarNotesUpdate);
+            AddLocalPacketHandler(PacketType.AvatarInterestsUpdate, HandleAvatarInterestsUpdate);
             AddLocalPacketHandler(PacketType.GrantUserRights, HandleGrantUserRights);
             AddLocalPacketHandler(PacketType.PlacesQuery, HandlePlacesQuery);
             AddLocalPacketHandler(PacketType.UpdateMuteListEntry, HandleUpdateMuteListEntry);
@@ -5798,7 +6265,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.GroupVoteHistoryRequest, HandleGroupVoteHistoryRequest);
             AddLocalPacketHandler(PacketType.SimWideDeletes, HandleSimWideDeletes);
             AddLocalPacketHandler(PacketType.SendPostcard, HandleSendPostcard);
-
+            AddLocalPacketHandler(PacketType.ChangeInventoryItemFlags, HandleChangeInventoryItemFlags);
+            AddLocalPacketHandler(PacketType.RevokePermissions, HandleRevokePermissions);
             AddGenericPacketHandler("autopilot", HandleAutopilot);
         }
 
@@ -5809,7 +6277,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         #region Scene/Avatar
 
         // Threshold for body rotation to be a significant agent update
-        private const float QDELTA = 0.000001f;
+        // 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;
 
@@ -5832,27 +6302,28 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name='x'></param>
         private bool CheckAgentMovementUpdateSignificance(AgentUpdatePacket.AgentDataBlock x)
         {
-            float qdelta1 = 1 - (float)Math.Pow(Quaternion.Dot(x.BodyRotation, m_thisAgentUpdateArgs.BodyRotation), 2);
-            //qdelta2 = 1 - (float)Math.Pow(Quaternion.Dot(x.HeadRotation, m_thisAgentUpdateArgs.HeadRotation), 2);
-
-            bool movementSignificant =
-                (qdelta1 > QDELTA)                                          // significant if body rotation above threshold
-                // Ignoring head rotation altogether, because it's not being used for anything interesting up the stack
-                // || (qdelta2 > QDELTA * 10)                               // significant if head rotation above threshold
-                || (x.ControlFlags != m_thisAgentUpdateArgs.ControlFlags)   // significant if control flags changed
-                || (x.ControlFlags != (byte)AgentManager.ControlFlags.NONE) // significant if user supplying any movement update commands
-                || (x.Far != m_thisAgentUpdateArgs.Far)                     // significant if far distance changed
+            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
-            ;
-            //if (movementSignificant)
-            //{
-                //m_log.DebugFormat("[LLCLIENTVIEW]: Bod {0} {1}",
-                //    qdelta1, qdelta2);
-                //m_log.DebugFormat("[LLCLIENTVIEW]: St {0} {1} {2} {3}",
-                //    x.ControlFlags, x.Flags, x.Far, x.State);
-            //}
-            return movementSignificant;
+                || (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>
@@ -5863,78 +6334,95 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name='x'></param>
         private bool CheckAgentCameraUpdateSignificance(AgentUpdatePacket.AgentDataBlock x)
         {
-            float vdelta1 = Vector3.Distance(x.CameraAtAxis, m_thisAgentUpdateArgs.CameraAtAxis);
-            float vdelta2 = Vector3.Distance(x.CameraCenter, m_thisAgentUpdateArgs.CameraCenter);
-            float vdelta3 = Vector3.Distance(x.CameraLeftAxis, m_thisAgentUpdateArgs.CameraLeftAxis);
-            float vdelta4 = Vector3.Distance(x.CameraUpAxis, m_thisAgentUpdateArgs.CameraUpAxis);
+            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 ||
 
-            bool cameraSignificant =
-                (vdelta1 > VDELTA) ||
-                (vdelta2 > VDELTA) ||
-                (vdelta3 > VDELTA) ||
-                (vdelta4 > 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 ||
 
-            //if (cameraSignificant)
-            //{
-                //m_log.DebugFormat("[LLCLIENTVIEW]: Cam1 {0} {1}",
-                //    x.CameraAtAxis, x.CameraCenter);
-                //m_log.DebugFormat("[LLCLIENTVIEW]: Cam2 {0} {1}",
-                //    x.CameraLeftAxis, x.CameraUpAxis);
-            //}
+               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 ||
 
-            return cameraSignificant;
-        }
+               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;
 
-        private bool HandleAgentUpdate(IClientAPI sener, Packet packet)
-        {            
-            // We got here, which means that something in agent update was significant
+            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;
 
-            // Before we update the current m_thisAgentUpdateArgs, let's check this again
-            // to see what exactly changed
             bool movement = CheckAgentMovementUpdateSignificance(x);
             bool camera = CheckAgentCameraUpdateSignificance(x);
 
-            m_thisAgentUpdateArgs.AgentID = x.AgentID;
-            m_thisAgentUpdateArgs.BodyRotation = x.BodyRotation;
-            m_thisAgentUpdateArgs.CameraAtAxis = x.CameraAtAxis;
-            m_thisAgentUpdateArgs.CameraCenter = x.CameraCenter;
-            m_thisAgentUpdateArgs.CameraLeftAxis = x.CameraLeftAxis;
-            m_thisAgentUpdateArgs.CameraUpAxis = x.CameraUpAxis;
-            m_thisAgentUpdateArgs.ControlFlags = x.ControlFlags;
-            m_thisAgentUpdateArgs.Far = x.Far;
-            m_thisAgentUpdateArgs.Flags = x.Flags;
-            m_thisAgentUpdateArgs.HeadRotation = x.HeadRotation;
-            m_thisAgentUpdateArgs.SessionID = x.SessionID;
-            m_thisAgentUpdateArgs.State = x.State;
-
-            UpdateAgent handlerAgentUpdate = OnAgentUpdate;
-            UpdateAgent handlerPreAgentUpdate = OnPreAgentUpdate;
-            UpdateAgent handlerAgentCameraUpdate = OnAgentCameraUpdate;
-
             // 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);
 
-            handlerAgentUpdate = null;
-            handlerPreAgentUpdate = null;
-            handlerAgentCameraUpdate = null;
+            }
 
             PacketPool.Instance.ReturnPacket(packet);
 
@@ -5967,6 +6455,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             ParcelGodMarkAsContentPacket ParcelGodMarkAsContent =
                 (ParcelGodMarkAsContentPacket)Packet;
 
+            if(SessionId != ParcelGodMarkAsContent.AgentData.SessionID || AgentId != ParcelGodMarkAsContent.AgentData.AgentID)
+                return false;
+
             ParcelGodMark ParcelGodMarkAsContentHandler = OnParcelGodMark;
             if (ParcelGodMarkAsContentHandler != null)
             {
@@ -5982,6 +6473,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             FreezeUserPacket FreezeUser = (FreezeUserPacket)Packet;
 
+            if(SessionId != FreezeUser.AgentData.SessionID || AgentId != FreezeUser.AgentData.AgentID)
+                return false;
+
             FreezeUserUpdate FreezeUserHandler = OnParcelFreezeUser;
             if (FreezeUserHandler != null)
             {
@@ -5999,6 +6493,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             EjectUserPacket EjectUser =
                 (EjectUserPacket)Packet;
 
+            if(SessionId != EjectUser.AgentData.SessionID || AgentId != EjectUser.AgentData.AgentID)
+                return false;
+
             EjectUserUpdate EjectUserHandler = OnParcelEjectUser;
             if (EjectUserHandler != null)
             {
@@ -6016,6 +6513,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             ParcelBuyPassPacket ParcelBuyPass =
                 (ParcelBuyPassPacket)Packet;
 
+            if(SessionId != ParcelBuyPass.AgentData.SessionID || AgentId != ParcelBuyPass.AgentData.AgentID)
+                return false;
+
             ParcelBuyPass ParcelBuyPassHandler = OnParcelBuyPass;
             if (ParcelBuyPassHandler != null)
             {
@@ -6048,8 +6548,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private bool HandleUUIDGroupNameRequest(IClientAPI sender, Packet Pack)
         {
-            UUIDGroupNameRequestPacket upack = (UUIDGroupNameRequestPacket)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++)
             {
@@ -6101,7 +6604,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                 }
             }
-            
+
             //m_log.Debug("[LLCLIENTVIEW]: Not handling GenericMessage with method-type of: " + method);
             return false;
         }
@@ -6150,6 +6653,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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;
@@ -6442,11 +6968,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             RezObject handlerRezObject = OnRezObject;
             if (handlerRezObject != null)
             {
-                handlerRezObject(this, rezPacket.InventoryData.ItemID, rezPacket.RezData.RayEnd,
-                                 rezPacket.RezData.RayStart, rezPacket.RezData.RayTargetID,
-                                 rezPacket.RezData.BypassRaycast, rezPacket.RezData.RayEndIsIntersection,
-                                 rezPacket.RezData.RezSelected, rezPacket.RezData.RemoveItem,
-                                 rezPacket.RezData.FromTaskID);
+                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;
         }
@@ -6485,6 +7014,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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;
@@ -6501,9 +7050,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             //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, 
+                // 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.
-                m_justEditedTerrain = true; // Prevent terrain packet (Land layer) from being queued, make it unreliable
                 if (OnModifyTerrain != null)
                 {
                     for (int i = 0; i < modify.ParcelData.Length; i++)
@@ -6519,7 +7067,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         }
                     }
                 }
-                m_justEditedTerrain = false; // Queue terrain packet (Land layer) if necessary, make it reliable again
             }
 
             return true;
@@ -6580,7 +7127,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     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]; 
+                    //var b = appear.WearableData[0];
 
                     Primitive.TextureEntry te = null;
                     if (appear.ObjectData.TextureEntry.Length > 1)
@@ -6588,7 +7135,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     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)};
+                        cacheitems[i] = new WearableCacheItem(){
+                            CacheId = appear.WearableData[i].CacheID,
+                            TextureIndex=Convert.ToUInt32(appear.WearableData[i].TextureIndex)
+                        };
 
 
 
@@ -6794,13 +7344,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return true;
         }
 
-        private bool HandleCompleteAgentMovement(IClientAPI sender, Packet Pack)
+      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;
@@ -6818,7 +7373,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     return true;
             }
             #endregion
-
+/*
             StartAnim handlerStartAnim = null;
             StopAnim handlerStopAnim = null;
 
@@ -6842,6 +7397,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 }
             }
             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)
@@ -6997,7 +7571,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 SendUserInfoReply(false, true, "");
             }
             return true;
-
         }
 
         private bool HandleUpdateUserInfo(IClientAPI sender, Packet Pack)
@@ -7087,6 +7660,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             #endregion
 
             m_udpClient.SetThrottles(atpack.Throttle.Throttles);
+            GenericCall2 handler = OnUpdateThrottles;
+            if (handler != null)
+            {
+                handler();
+            }
             return true;
         }
 
@@ -7207,7 +7785,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 AddNewPrim handlerAddPrim = OnAddPrim;
                 if (handlerAddPrim != null)
-                    handlerAddPrim(AgentId, ActiveGroupId, addPacket.ObjectData.RayEnd, addPacket.ObjectData.Rotation, shape, addPacket.ObjectData.BypassRaycast, addPacket.ObjectData.RayStart, addPacket.ObjectData.RayTargetID, addPacket.ObjectData.RayEndIsIntersection);
+                    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;
         }
@@ -7302,14 +7880,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             ObjectDuplicate handlerObjectDuplicate = null;
 
-            for (int i = 0; i < dupe.ObjectData.Length; i++)
+            handlerObjectDuplicate = OnObjectDuplicate;
+            if (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,
-                                           ActiveGroupId);
+                                           rezGroupID);
                 }
             }
 
@@ -7354,16 +7935,19 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     return true;
             }
             #endregion
-
+            List<uint> thisSelection = new List<uint>();
             ObjectSelect handlerObjectSelect = null;
-
-            for (int i = 0; i < incomingselect.ObjectData.Length; i++)
+            uint objID;
+            handlerObjectSelect = OnObjectSelect;
+            if (handlerObjectSelect != null)
             {
-                handlerObjectSelect = OnObjectSelect;
-                if (handlerObjectSelect != null)
+                for (int i = 0; i < incomingselect.ObjectData.Length; i++)
                 {
-                    handlerObjectSelect(incomingselect.ObjectData[i].ObjectLocalID, this);
+                    objID = incomingselect.ObjectData[i].ObjectLocalID;
+                    thisSelection.Add(objID);
                 }
+
+                handlerObjectSelect(thisSelection, this);
             }
             return true;
         }
@@ -7382,13 +7966,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             #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(incomingdeselect.ObjectData[i].ObjectLocalID, this);
+                   OnObjectDeselect(objID, this);
                 }
             }
             return true;
@@ -7511,7 +8097,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     physdata.Bounce = phsblock.Restitution;
                     physdata.Density = phsblock.Density;
                     physdata.Friction = phsblock.Friction;
-                    physdata.GravitationModifier = phsblock.GravityMultiplier;   
+                    physdata.GravitationModifier = phsblock.GravityMultiplier;
                 }
 
                 handlerUpdatePrimFlags(flags.AgentData.ObjectLocalID, UsePhysics, IsTemporary, IsPhantom, physdata, this);
@@ -7519,19 +8105,41 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return true;
         }
 
+        Dictionary<uint, uint> objImageSeqs = null;
+        double lastobjImageSeqsMS = 0.0;
+
         private bool HandleObjectImage(IClientAPI sender, Packet Pack)
         {
             ObjectImagePacket imagePack = (ObjectImagePacket)Pack;
 
-            UpdatePrimTexture handlerUpdatePrimTexture = null;
+            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++)
             {
-                handlerUpdatePrimTexture = OnUpdatePrimTexture;
-                if (handlerUpdatePrimTexture != null)
-                {
-                    handlerUpdatePrimTexture(imagePack.ObjectData[i].ObjectLocalID,
-                                             imagePack.ObjectData[i].TextureEntry, this);
-                }
+                    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;
         }
@@ -7605,6 +8213,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         touchArgs.Add(arg);
                     }
                 }
+
                 handlerGrabUpdate(grabUpdate.ObjectData.ObjectID, grabUpdate.ObjectData.GrabOffsetInitial,
                                   grabUpdate.ObjectData.GrabPosition, this, touchArgs);
             }
@@ -7921,10 +8530,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 handlerObjectDuplicateOnRay = OnObjectDuplicateOnRay;
                 if (handlerObjectDuplicateOnRay != null)
                 {
-                    handlerObjectDuplicateOnRay(dupeOnRay.ObjectData[i].ObjectLocalID, dupeOnRay.AgentData.DuplicateFlags,
-                                                AgentId, ActiveGroupId, dupeOnRay.AgentData.RayTargetID, dupeOnRay.AgentData.RayEnd,
-                                                dupeOnRay.AgentData.RayStart, dupeOnRay.AgentData.BypassRaycast, dupeOnRay.AgentData.RayEndIsIntersection,
-                                                dupeOnRay.AgentData.CopyCenters, dupeOnRay.AgentData.CopyRotates);
+
+                    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);
                 }
             }
 
@@ -9106,7 +9722,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 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)) )
+                            && (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;
@@ -9131,6 +9747,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         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)
@@ -9148,13 +9768,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private bool HandleRegionHandleRequest(IClientAPI sender, Packet Pack)
         {
-            RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack;
-
             RegionHandleRequest handlerRegionHandleRequest = OnRegionHandleRequest;
+
             if (handlerRegionHandleRequest != null)
             {
+                RegionHandleRequestPacket rhrPack = (RegionHandleRequestPacket)Pack;
                 handlerRegionHandleRequest(this, rhrPack.RequestBlock.RegionID);
             }
+
             return true;
         }
 
@@ -9730,6 +10351,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     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)));
 
                     }
@@ -9765,7 +10387,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             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);
@@ -9907,7 +10529,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     return true;
 
                 case "kickestate":
-                   
+
                     if(((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
                     {
                         UUID invoice = messagePacket.MethodData.Invoice;
@@ -9986,6 +10608,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         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;
 
@@ -9995,7 +10622,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             if (handlerReqGodlikePowers != null)
             {
-                handlerReqGodlikePowers(ablock.AgentID, ablock.SessionID, token, rblock.Godlike, this);
+                handlerReqGodlikePowers(ablock.AgentID, ablock.SessionID, token, rblock.Godlike);
             }
 
             return true;
@@ -10006,6 +10633,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             GodUpdateRegionInfoPacket GodUpdateRegionInfo =
                 (GodUpdateRegionInfoPacket)Packet;
 
+            if (GodUpdateRegionInfo.AgentData.SessionID != SessionId ||
+                    GodUpdateRegionInfo.AgentData.AgentID != AgentId)
+                return true;
+
             GodUpdateRegionInfoUpdate handlerGodUpdateRegionInfo = OnGodUpdateRegionInfoUpdate;
             if (handlerGodUpdateRegionInfo != null)
             {
@@ -10039,6 +10670,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             GodlikeMessagePacket GodlikeMessage =
                 (GodlikeMessagePacket)Packet;
 
+            if (GodlikeMessage.AgentData.SessionID != SessionId ||
+                    GodlikeMessage.AgentData.AgentID != AgentId)
+                return true;
+
             GodlikeMessage handlerGodlikeMessage = onGodlikeMessage;
             if (handlerGodlikeMessage != null)
             {
@@ -10055,6 +10690,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             StateSavePacket SaveStateMessage =
                 (StateSavePacket)Packet;
+
+            if (SaveStateMessage.AgentData.SessionID != SessionId ||
+                    SaveStateMessage.AgentData.AgentID != AgentId)
+                return true;
+
             SaveStateHandler handlerSaveStatePacket = OnSaveState;
             if (handlerSaveStatePacket != null)
             {
@@ -10068,30 +10708,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             GodKickUserPacket gkupack = (GodKickUserPacket)Pack;
 
-            if (gkupack.UserInfo.GodSessionID == SessionId && AgentId == gkupack.UserInfo.GodID)
-            {
-                GodKickUser handlerGodKickUser = OnGodKickUser;
-                if (handlerGodKickUser != null)
-                {
-                    handlerGodKickUser(gkupack.UserInfo.GodID, gkupack.UserInfo.GodSessionID,
-                                       gkupack.UserInfo.AgentID, gkupack.UserInfo.KickFlags, gkupack.UserInfo.Reason);
-                }
-            }
-            else
+            if (gkupack.UserInfo.GodSessionID != SessionId ||
+                    gkupack.UserInfo.GodID != AgentId)
+                return true;
+
+            GodKickUser handlerGodKickUser = OnGodKickUser;
+            if (handlerGodKickUser != null)
             {
-                SendAgentAlertMessage("Kick request denied", false);
+                handlerGodKickUser(gkupack.UserInfo.GodID, gkupack.UserInfo.AgentID, gkupack.UserInfo.KickFlags, gkupack.UserInfo.Reason);
             }
-            //KickUserPacket kupack = new KickUserPacket();
-            //KickUserPacket.UserInfoBlock kupackib = kupack.UserInfo;
-
-            //kupack.UserInfo.AgentID = gkupack.UserInfo.AgentID;
-            //kupack.UserInfo.SessionID = gkupack.UserInfo.GodSessionID;
 
-            //kupack.TargetBlock.TargetIP = (uint)0;
-            //kupack.TargetBlock.TargetPort = (ushort)0;
-            //kupack.UserInfo.Reason = gkupack.UserInfo.Reason;
-
-            //OutPacket(kupack, ThrottleOutPacketType.Task);
             return true;
         }
         #endregion GodPackets
@@ -10410,9 +11036,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             else
             {
-                SendUseCachedMuteList();
+                 if(muteListRequest.MuteData.MuteCRC == 0)
+                    SendEmpytMuteList();
+                else
+                    SendUseCachedMuteList();
             }
-            return true;
+            return true;           
         }
 
         private bool HandleUpdateMuteListEntry(IClientAPI client, Packet Packet)
@@ -10425,7 +11054,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 handlerUpdateMuteListEntry(this, UpdateMuteListEntry.MuteData.MuteID,
                                            Utils.BytesToString(UpdateMuteListEntry.MuteData.MuteName),
                                            UpdateMuteListEntry.MuteData.MuteType,
-                                           UpdateMuteListEntry.AgentData.AgentID);
+                                           UpdateMuteListEntry.MuteData.MuteFlags);
                 return true;
             }
             return false;
@@ -10440,8 +11069,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 handlerRemoveMuteListEntry(this,
                                            RemoveMuteListEntry.MuteData.MuteID,
-                                           Utils.BytesToString(RemoveMuteListEntry.MuteData.MuteName),
-                                           RemoveMuteListEntry.AgentData.AgentID);
+                                           Utils.BytesToString(RemoveMuteListEntry.MuteData.MuteName));
                 return true;
             }
             return false;
@@ -10485,16 +11113,62 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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;
@@ -10748,7 +11422,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (m_GroupsModule != null)
             {
                 m_GroupsModule.ActivateGroup(this, activateGroupPacket.AgentData.GroupID);
-                m_GroupsModule.SendAgentGroupDataUpdate(this);
             }
             return true;
 
@@ -10873,11 +11546,19 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             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)
             {
@@ -10887,36 +11568,62 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             #endregion
 
-            if (m_GroupsModule != null)
-            {
-                GroupProfileReplyPacket groupProfileReply = (GroupProfileReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupProfileReply);
+            UUID grpID = groupProfileRequest.GroupData.GroupID;
+            double ts = Util.GetTimeStampMS();
+            if(grpID == lastGroupProfileRequestID && ts - lastGroupProfileRequestTS < 10000)
+                return true;
 
-                groupProfileReply.AgentData = new GroupProfileReplyPacket.AgentDataBlock();
-                groupProfileReply.GroupData = new GroupProfileReplyPacket.GroupDataBlock();
-                groupProfileReply.AgentData.AgentID = AgentId;
+            lastGroupProfileRequestID = grpID;
+            lastGroupProfileRequestTS = ts;
 
-                GroupProfileData d = m_GroupsModule.GroupProfileRequest(this,
-                                                                        groupProfileRequest.GroupData.GroupID);
+            GroupProfileReplyPacket groupProfileReply = (GroupProfileReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupProfileReply);
 
-                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;
+            groupProfileReply.AgentData = new GroupProfileReplyPacket.AgentDataBlock();
+            groupProfileReply.GroupData = new GroupProfileReplyPacket.GroupDataBlock();
+            groupProfileReply.AgentData.AgentID = AgentId;
 
-                OutPacket(groupProfileReply, ThrottleOutPacketType.Task);
+            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)
@@ -10939,12 +11646,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     m_GroupsModule.GroupMembersRequest(this, groupMembersRequestPacket.GroupData.GroupID);
 
                 int memberCount = members.Count;
-
-                while (true)
+                int indx = 0;
+                while (indx < memberCount)
                 {
-                    int blockCount = members.Count;
-                    if (blockCount > 40)
-                        blockCount = 40;
+                    int blockCount = memberCount - indx;
+                    if (blockCount > 25)
+                        blockCount = 25;
 
                     GroupMembersReplyPacket groupMembersReply = (GroupMembersReplyPacket)PacketPool.Instance.GetPacket(PacketType.GroupMembersReply);
 
@@ -10965,8 +11672,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     for (int i = 0; i < blockCount; i++)
                     {
-                        GroupMembersData m = members[0];
-                        members.RemoveAt(0);
+                        GroupMembersData m = members[indx++];
 
                         groupMembersReply.MemberData[i] =
                             new GroupMembersReplyPacket.MemberDataBlock();
@@ -10984,8 +11690,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             m.IsOwner;
                     }
                     OutPacket(groupMembersReply, ThrottleOutPacketType.Task);
-                    if (members.Count == 0)
-                        return true;
                 }
             }
             return true;
@@ -11488,11 +12192,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             StartLure handlerStartLure = OnStartLure;
             if (handlerStartLure != null)
-                handlerStartLure(startLureRequest.Info.LureType,
-                                 Utils.BytesToString(
-                                    startLureRequest.Info.Message),
-                                 startLureRequest.TargetData[0].TargetID,
-                                 this);
+            {
+                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)
@@ -11606,10 +12315,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             #endregion
 
-            ClassifiedDelete handlerClassifiedGodDelete = OnClassifiedGodDelete;
+            ClassifiedGodDelete handlerClassifiedGodDelete = OnClassifiedGodDelete;
             if (handlerClassifiedGodDelete != null)
                 handlerClassifiedGodDelete(
                          classifiedGodDelete.Data.ClassifiedID,
+                         classifiedGodDelete.Data.QueryID,
                          this);
             return true;
         }
@@ -11833,6 +12543,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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 =
@@ -11865,7 +12593,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             scriptQuestion.Data.Questions = question;
             scriptQuestion.Data.ObjectName = Util.StringToBytes256(taskName);
             scriptQuestion.Data.ObjectOwner = Util.StringToBytes256(ownerName);
-            
+
             OutPacket(scriptQuestion, ThrottleOutPacketType.Task);
         }
 
@@ -11912,86 +12640,52 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <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 = m_cachedTextureSerial;
-            m_cachedTextureSerial++;
+            cachedresp.AgentData.SerialNum = cachedtex.AgentData.SerialNum;
             cachedresp.WearableData =
                 new AgentCachedTextureResponsePacket.WearableDataBlock[cachedtex.WearableData.Length];
 
-            int maxWearablesLoop = cachedtex.WearableData.Length;
-            if (maxWearablesLoop > AvatarWearable.MAX_WEARABLES)
-                maxWearablesLoop = AvatarWearable.MAX_WEARABLES;
+            int cacheHits = 0;
 
-            // Find the cached baked textures for this user, if they're available
+            // 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
 
-            IAssetService cache = m_scene.AssetService;
-            IBakedTextureModule bakedTextureModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
-            
             WearableCacheItem[] cacheItems = null;
 
-            if (bakedTextureModule != null && cache != null)
-            {
-                ScenePresence p = m_scene.GetScenePresence(AgentId);
-                if (p.Appearance != null)
-                {
-                    if (p.Appearance.WearableCacheItems == null || p.Appearance.WearableCacheItemsDirty)
-                    {
-                        try
-                        {
-                            cacheItems = bakedTextureModule.Get(AgentId);
-                            p.Appearance.WearableCacheItems = cacheItems;
-                            p.Appearance.WearableCacheItemsDirty = false;
-                        }
-                        catch (Exception)
-                        {
-                            cacheItems = null;
-                        }
+            ScenePresence p = m_scene.GetScenePresence(AgentId);
 
-                    }
-                    else if (p.Appearance.WearableCacheItems != null)
-                    {
-                        cacheItems = p.Appearance.WearableCacheItems;
-                    }
-                }
+            if (p != null && p.Appearance != null)
+            {
+                cacheItems = p.Appearance.WearableCacheItems;
             }
 
+            int maxWearablesLoop = cachedtex.WearableData.Length;
+
             if (cacheItems != null)
             {
-                // We need to make sure the asset stored in the bake is available on this server also by its assetid before we map it to a Cacheid.
-                // Copy the baked textures to the sim's assets cache (local only).
-                foreach (WearableCacheItem item in cacheItems)
-                {
-                    if (cache.GetCached(item.TextureID.ToString()) == null)
-                    {
-                        item.TextureAsset.Temporary = true;
-                        item.TextureAsset.Local = true;
-                        cache.Store(item.TextureAsset);
-                    }
-                }
-
-                // Return the cached textures
+                if (maxWearablesLoop > cacheItems.Length)
+                    maxWearablesLoop = cacheItems.Length;
                 for (int i = 0; i < maxWearablesLoop; i++)
                 {
-                    WearableCacheItem item =
-                        WearableCacheItem.SearchTextureIndex(cachedtex.WearableData[i].TextureIndex, cacheItems);
-
+                    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 (item != null && cachedtex.WearableData[i].ID == item.CacheId)
+                    if (cachedtex.WearableData[i].ID == cacheItems[idx].CacheId)
                     {
-                        cachedresp.WearableData[i].TextureID = item.TextureID;
+                        cachedresp.WearableData[i].TextureID = cacheItems[idx].TextureID;
+                        cacheHits++;
                     }
                     else
                     {
@@ -12001,7 +12695,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             else
             {
-                // Cached textures not available
                 for (int i = 0; i < maxWearablesLoop; i++)
                 {
                     cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
@@ -12010,13 +12703,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     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.
@@ -12080,209 +12775,147 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     else
                     {
-//                        m_log.DebugFormat(
-//                            "[CLIENT]: Processing block {0} type {1} for {2} {3}",
-//                            i, block.Type, part.Name, part.LocalId);
+                        ClientChangeObject updatehandler = onClientChangeObject;
 
-//                        // Do this once since fetch parts creates a new array.
-//                        SceneObjectPart[] parts = part.ParentGroup.Parts;
-//                        for (int j = 0; j < parts.Length; j++)
-//                        {
-//                            part.StoreUndoState();
-//                            parts[j].IgnoreUndoUpdate = true;
-//                        }
+                        if (updatehandler != null)
+                        {
+                            ObjectChangeData udata = new ObjectChangeData();
 
-                        UpdatePrimGroupRotation handlerUpdatePrimGroupRotation;
+                            /*ubit from ll JIRA:
+                             * 0x01 position
+                             * 0x02 rotation
+                             * 0x04 scale
 
-                        switch (block.Type)
-                        {
-                            case 1:
-                                Vector3 pos1 = new Vector3(block.Data, 0);
+                             * 0x08 LINK_SET
+                             * 0x10 UNIFORM for scale
+                             */
 
-                                UpdateVector handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
-                                if (handlerUpdatePrimSinglePosition != null)
-                                {
-                                    // m_log.Debug("new movement position is " + pos.X + " , " + pos.Y + " , " + pos.Z);
-                                    handlerUpdatePrimSinglePosition(localId, pos1, this);
-                                }
-                                break;
+                            // translate to internal changes
+                            // not all cases .. just the ones older code did
 
-                            case 2:
-                                Quaternion rot1 = new Quaternion(block.Data, 0, true);
+                            switch (block.Type)
+                            {
+                                case 1: //change position sp
+                                    udata.position = new Vector3(block.Data, 0);
 
-                                UpdatePrimSingleRotation handlerUpdatePrimSingleRotation = OnUpdatePrimSingleRotation;
-                                if (handlerUpdatePrimSingleRotation != null)
-                                {
-                                    // m_log.Info("new tab rotation is " + rot1.X + " , " + rot1.Y + " , " + rot1.Z + " , " + rot1.W);
-                                    handlerUpdatePrimSingleRotation(localId, rot1, this);
-                                }
-                                break;
+                                    udata.change = ObjectChangeType.primP;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                            case 3:
-                                Vector3 rotPos = new Vector3(block.Data, 0);
-                                Quaternion rot2 = new Quaternion(block.Data, 12, true);
+                                case 2: // rotation sp
+                                    udata.rotation = new Quaternion(block.Data, 0, true);
 
-                                UpdatePrimSingleRotationPosition handlerUpdatePrimSingleRotationPosition = OnUpdatePrimSingleRotationPosition;
-                                if (handlerUpdatePrimSingleRotationPosition != null)
-                                {
-                                    // m_log.Debug("new mouse rotation position is " + rotPos.X + " , " + rotPos.Y + " , " + rotPos.Z);
-                                    // m_log.Info("new mouse rotation is " + rot2.X + " , " + rot2.Y + " , " + rot2.Z + " , " + rot2.W);
-                                    handlerUpdatePrimSingleRotationPosition(localId, rot2, rotPos, this);
-                                }
-                                break;
+                                    udata.change = ObjectChangeType.primR;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                            case 4:
-                            case 20:
-                                Vector3 scale4 = new Vector3(block.Data, 0);
+                                case 3: // position plus rotation
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.rotation = new Quaternion(block.Data, 12, true);
 
-                                UpdateVector handlerUpdatePrimScale = OnUpdatePrimScale;
-                                if (handlerUpdatePrimScale != null)
-                                {
-                                    //                                     m_log.Debug("new scale is " + scale4.X + " , " + scale4.Y + " , " + scale4.Z);
-                                    handlerUpdatePrimScale(localId, scale4, this);
-                                }
-                                break;
+                                    udata.change = ObjectChangeType.primPR;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                            case 5:
-                                Vector3 scale1 = new Vector3(block.Data, 12);
-                                Vector3 pos11 = new Vector3(block.Data, 0);
+                                case 4: // scale sp
+                                    udata.scale = new Vector3(block.Data, 0);
+                                    udata.change = ObjectChangeType.primS;
 
-                                handlerUpdatePrimScale = OnUpdatePrimScale;
-                                if (handlerUpdatePrimScale != null)
-                                {
-                                    // m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
-                                    handlerUpdatePrimScale(localId, scale1, this);
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                                    handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
-                                    if (handlerUpdatePrimSinglePosition != null)
-                                    {
-                                        handlerUpdatePrimSinglePosition(localId, pos11, this);
-                                    }
-                                }
-                                break;
+                                case 0x14: // uniform scale sp
+                                    udata.scale = new Vector3(block.Data, 0);
 
-                            case 9:
-                                Vector3 pos2 = new Vector3(block.Data, 0);
+                                    udata.change = ObjectChangeType.primUS;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                                UpdateVector handlerUpdateVector = OnUpdatePrimGroupPosition;
+                                case 5: // scale and position sp
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.scale = new Vector3(block.Data, 12);
 
-                                if (handlerUpdateVector != null)
-                                {
-                                    handlerUpdateVector(localId, pos2, this);
-                                }
-                                break;
+                                    udata.change = ObjectChangeType.primPS;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                            case 10:
-                                Quaternion rot3 = new Quaternion(block.Data, 0, true);
+                                case 0x15: //uniform scale and position
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.scale = new Vector3(block.Data, 12);
 
-                                UpdatePrimRotation handlerUpdatePrimRotation = OnUpdatePrimGroupRotation;
-                                if (handlerUpdatePrimRotation != null)
-                                {
-                                    //  Console.WriteLine("new rotation is " + rot3.X + " , " + rot3.Y + " , " + rot3.Z + " , " + rot3.W);
-                                    handlerUpdatePrimRotation(localId, rot3, this);
-                                }
-                                break;
+                                    udata.change = ObjectChangeType.primPUS;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                            case 11:
-                                Vector3 pos3 = new Vector3(block.Data, 0);
-                                Quaternion rot4 = new Quaternion(block.Data, 12, true);
+                                // now group related (bit 4)
+                                case 9: //( 8 + 1 )group position
+                                    udata.position = new Vector3(block.Data, 0);
 
-                                handlerUpdatePrimGroupRotation = OnUpdatePrimGroupMouseRotation;
-                                if (handlerUpdatePrimGroupRotation != null)
-                                {
-                                    //  m_log.Debug("new rotation position is " + pos.X + " , " + pos.Y + " , " + pos.Z);
-                                    // m_log.Debug("new group mouse rotation is " + rot4.X + " , " + rot4.Y + " , " + rot4.Z + " , " + rot4.W);
-                                    handlerUpdatePrimGroupRotation(localId, pos3, rot4, this);
-                                }
-                                break;
-                            case 12:
-                            case 28:
-                                Vector3 scale7 = new Vector3(block.Data, 0);
+                                    udata.change = ObjectChangeType.groupP;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                                UpdateVector handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;
-                                if (handlerUpdatePrimGroupScale != null)
-                                {
-                                    //                                     m_log.Debug("new scale is " + scale7.X + " , " + scale7.Y + " , " + scale7.Z);
-                                    handlerUpdatePrimGroupScale(localId, scale7, this);
-                                }
-                                break;
+                                case 0x0A: // (8 + 2) group rotation
+                                    udata.rotation = new Quaternion(block.Data, 0, true);
 
-                            case 13:
-                                Vector3 scale2 = new Vector3(block.Data, 12);
-                                Vector3 pos4 = new Vector3(block.Data, 0);
+                                    udata.change = ObjectChangeType.groupR;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                                handlerUpdatePrimScale = OnUpdatePrimScale;
-                                if (handlerUpdatePrimScale != null)
-                                {
-                                    //m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
-                                    handlerUpdatePrimScale(localId, scale2, this);
+                                case 0x0B: //( 8 + 2 + 1) group rotation and position
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.rotation = new Quaternion(block.Data, 12, true);
 
-                                    // Change the position based on scale (for bug number 246)
-                                    handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
-                                    // m_log.Debug("new movement position is " + pos.X + " , " + pos.Y + " , " + pos.Z);
-                                    if (handlerUpdatePrimSinglePosition != null)
-                                    {
-                                        handlerUpdatePrimSinglePosition(localId, pos4, this);
-                                    }
-                                }
-                                break;
+                                    udata.change = ObjectChangeType.groupPR;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                            case 29:
-                                Vector3 scale5 = new Vector3(block.Data, 12);
-                                Vector3 pos5 = new Vector3(block.Data, 0);
+                                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
 
-                                handlerUpdatePrimGroupScale = OnUpdatePrimGroupScale;
-                                if (handlerUpdatePrimGroupScale != null)
-                                {
-                                    // m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
-                                    part.StoreUndoState(true);
-                                    part.IgnoreUndoUpdate = true;
-                                    handlerUpdatePrimGroupScale(localId, scale5, this);
-                                    handlerUpdateVector = OnUpdatePrimGroupPosition;
+                                    udata.scale = new Vector3(block.Data, 0);
 
-                                    if (handlerUpdateVector != null)
-                                    {
-                                        handlerUpdateVector(localId, pos5, this);
-                                    }
+                                    udata.change = ObjectChangeType.groupS;
+                                    updatehandler(localId, udata, this);
 
-                                    part.IgnoreUndoUpdate = false;
-                                }
+                                    break;
 
-                                break;
+                                case 0x0D: //(8 + 4 + 1) group scale and position
+                                    // exception as above
 
-                            case 21:
-                                Vector3 scale6 = new Vector3(block.Data, 12);
-                                Vector3 pos6 = new Vector3(block.Data, 0);
+                                    udata.position = new Vector3(block.Data, 0);
+                                    udata.scale = new Vector3(block.Data, 12);
 
-                                handlerUpdatePrimScale = OnUpdatePrimScale;
-                                if (handlerUpdatePrimScale != null)
-                                {
-                                    part.StoreUndoState(false);
-                                    part.IgnoreUndoUpdate = true;
+                                    udata.change = ObjectChangeType.groupPS;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                                    // m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
-                                    handlerUpdatePrimScale(localId, scale6, this);
-                                    handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
-                                    if (handlerUpdatePrimSinglePosition != null)
-                                    {
-                                        handlerUpdatePrimSinglePosition(localId, pos6, this);
-                                    }
+                                case 0x1C: // (0x10 + 8 + 4 ) group scale UNIFORM
+                                    udata.scale = new Vector3(block.Data, 0);
 
-                                    part.IgnoreUndoUpdate = false;
-                                }
-                                break;
+                                    udata.change = ObjectChangeType.groupUS;
+                                    updatehandler(localId, udata, this);
+                                    break;
 
-                            default:
-                                m_log.Debug("[CLIENT]: MultipleObjUpdate recieved an unknown packet type: " + (block.Type));
-                                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;
+                            }
                         }
 
-//                        for (int j = 0; j < parts.Length; j++)
-//                            parts[j].IgnoreUndoUpdate = false;
                     }
                 }
             }
-
             return true;
         }
 
@@ -12342,7 +12975,31 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="throttles"></param>
         public void SetChildAgentThrottle(byte[] throttles)
         {
-            m_udpClient.SetThrottles(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>
@@ -12403,9 +13060,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// 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)
             {
@@ -12424,7 +13094,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 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;
@@ -12437,7 +13107,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         "[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);
         }
 
@@ -12450,8 +13120,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             uint regionY = 0;
 
             Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out regionX, out regionY);
-            locx = Convert.ToSingle(args[0]) - (float)regionX;
-            locy = Convert.ToSingle(args[1]) - (float)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;
@@ -12677,20 +13347,75 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void RefreshGroupMembership()
         {
-            if (m_GroupsModule != null)
+            lock(m_groupPowers)
             {
-                GroupMembershipData[] GroupMembership =
+                GroupMembershipData activeMembership = null;
+                if (m_GroupsModule != null)
+                {
+                    GroupMembershipData[] GroupMembership =
                         m_GroupsModule.GetMembershipData(AgentId);
 
-                m_groupPowers.Clear();
+                    m_groupPowers.Clear();
 
-                if (GroupMembership != null)
-                {
-                    for (int i = 0; i < GroupMembership.Length; i++)
+                    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)
                     {
-                        m_groupPowers[GroupMembership[i].GroupID] = GroupMembership[i].GroupPowers;
+                        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;
             }
         }
 
@@ -12736,7 +13461,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 //                "[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>
@@ -12782,7 +13510,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     SendAssetNotFound(req);
                     return;
                 }
-
             }
 
             if (transferRequest.TransferInfo.SourceType == (int)SourceType.Asset)
@@ -12819,7 +13546,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <returns></returns>
         private static int CalculateNumPackets(byte[] data)
         {
-            const uint m_maxPacketSize = 600;
+//            const uint m_maxPacketSize = 600;
+            uint m_maxPacketSize = MaxTransferBytesPerPacket;
             int numPackets = 1;
 
             if (data == null)
@@ -12858,11 +13586,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             /// </summary>
             public bool Async { get; set; }
 
-            /// <summary>
-            /// If async is true, should this packet be handled in the async engine or given directly to a threadpool
-            /// thread?
-            /// </summary>
-            public bool InEngine { get; set; }
         }
 
         public class AsyncPacketProcess
@@ -12930,7 +13653,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // this is the username of the *owner*
             dialog.Data.FirstName = Util.StringToBytes256(ownerFirstName);
             dialog.Data.LastName = Util.StringToBytes256(ownerLastName);
-            dialog.Data.Message =  Util.StringToBytes256(message);
+            dialog.Data.Message =  Util.StringToBytes(message,512);
 
             ScriptDialogPacket.ButtonsBlock[] buttons = new ScriptDialogPacket.ButtonsBlock[1];
             buttons[0] = new ScriptDialogPacket.ButtonsBlock();
@@ -12949,7 +13672,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (p is ScenePresence)
             {
 //                m_log.DebugFormat(
-//                    "[LLCLIENTVIEW]: Immediately sending terse agent update for {0} to {1} in {2}", 
+//                    "[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
@@ -12962,8 +13685,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 ImprovedTerseObjectUpdatePacket.ObjectDataBlock block =
                     CreateImprovedTerseBlock(p, false);
 
-                const float TIME_DILATION = 1.0f;
-                ushort timeDilation = Utils.FloatToUInt16(TIME_DILATION, 0.0f, 1.0f);
+//                const float TIME_DILATION = 1.0f;
+                ushort timeDilation = Utils.FloatToUInt16(m_scene.TimeDilation, 0.0f, 1.0f);;
 
                 ImprovedTerseObjectUpdatePacket packet
                     = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(
@@ -12986,7 +13709,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 PlacesReplyData[] data)
         {
             PlacesReplyPacket reply = null;
-            PlacesReplyPacket.QueryDataBlock[] dataBlocks = 
+            PlacesReplyPacket.QueryDataBlock[] dataBlocks =
                     new PlacesReplyPacket.QueryDataBlock[0];
 
             for (int i = 0 ; i < data.Length ; i++)
@@ -13164,7 +13887,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             foreach (InventoryItemBase item in items)
             {
                 OSDMap ItemDataMap = new OSDMap();
-                
+
                 ItemDataMap.Add("ItemID", OSD.FromUUID(item.ID));
                 ItemDataMap.Add("FolderID", OSD.FromUUID(item.Folder));
 
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs
index 41dd4d1..deefd40 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs
@@ -82,7 +82,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             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");
 
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs
index 0394e54..439621a 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs
@@ -52,7 +52,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     /// 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 
+    /// 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>
@@ -86,8 +86,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// 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 
-        { 
+        public int ThrottleDebugLevel
+        {
             get
             {
                 return m_throttleDebugLevel;
@@ -96,9 +96,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             set
             {
                 m_throttleDebugLevel = value;
+/*
                 m_throttleClient.DebugLevel = m_throttleDebugLevel;
                 foreach (TokenBucket tb in m_throttleCategories)
                     tb.DebugLevel = m_throttleDebugLevel;
+ */
             }
         }
         private int m_throttleDebugLevel;
@@ -118,18 +120,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <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 readonly IncomingPacketHistoryCollection PacketArchive = new IncomingPacketHistoryCollection(200);
-
-        /// <summary>
-        /// If true then we take action in response to unacked reliably sent packets such as resending the packet.
-        /// </summary>
-        public bool ProcessUnackedSends { get; set; }
+        public IncomingPacketHistoryCollection PacketArchive = new IncomingPacketHistoryCollection(200);
 
         /// <summary>Packets we have sent that need to be ACKed by the client</summary>
-        public readonly UnackedPacketCollection NeedAcks = new UnackedPacketCollection();
+        public UnackedPacketCollection NeedAcks = new UnackedPacketCollection();
 
         /// <summary>ACKs that are queued up, waiting to be sent to the client</summary>
-        public readonly OpenSim.Framework.LocklessQueue<uint> PendingAcks = new OpenSim.Framework.LocklessQueue<uint>();
+        public DoubleLocklessQueue<uint> PendingAcks = new DoubleLocklessQueue<uint>();
 
         /// <summary>Current packet sequence number</summary>
         public int CurrentSequence;
@@ -160,19 +157,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>Number of packets sent to this client</summary>
         public int PacketsSent;
         /// <summary>Number of packets resent to this client</summary>
-        public int PacketsResent;        
+        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 int m_nextOnQueueEmpty = 1;
+        private double m_nextOnQueueEmpty = 0;
 
         /// <summary>Throttle bucket for this agent's connection</summary>
-        private readonly AdaptiveTokenBucket m_throttleClient;
+        private AdaptiveTokenBucket m_throttleClient;
         public AdaptiveTokenBucket FlowThrottle
         {
             get { return m_throttleClient; }
@@ -181,10 +179,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>Throttle buckets for each packet category</summary>
         private readonly TokenBucket[] m_throttleCategories;
         /// <summary>Outgoing queues for throttled packets</summary>
-        private readonly OpenSim.Framework.LocklessQueue<OutgoingPacket>[] m_packetOutboxes = new OpenSim.Framework.LocklessQueue<OutgoingPacket>[THROTTLE_CATEGORY_COUNT];
+        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 readonly OutgoingPacket[] m_nextPackets = new OutgoingPacket[THROTTLE_CATEGORY_COUNT];
+        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;
 
@@ -193,13 +191,31 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         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>
@@ -232,31 +248,27 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (maxRTO != 0)
                 m_maxRTO = maxRTO;
 
-            ProcessUnackedSends = true;
+            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(
-                    string.Format("adaptive throttle for {0} in {1}", AgentID, server.Scene.Name), 
-                    parentThrottle, 0, rates.Total, rates.MinimumAdaptiveThrottleRate, rates.AdaptiveThrottlesEnabled);
+            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 OpenSim.Framework.LocklessQueue<OutgoingPacket>();
-
+                m_packetOutboxes[i] = new DoubleLocklessQueue<OutgoingPacket>();
                 // Initialize the token buckets that control the throttling for each category
-                m_throttleCategories[i]
-                    = new TokenBucket(
-                        string.Format("{0} throttle for {1} in {2}", type, AgentID, server.Scene.Name), 
-                    m_throttleClient, rates.GetRate(type), 0);
+                m_throttleCategories[i] = new TokenBucket(m_throttleClient, rates.GetRate(type), m_burst);
             }
 
             // Default the retransmission timeout to one second
@@ -264,6 +276,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             // 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>
@@ -280,9 +293,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             // pull the throttle out of the scene throttle
             m_throttleClient.Parent.UnregisterRequest(m_throttleClient);
-            OnPacketStats = null;
-            OnQueueEmpty = null;
-        }
+            PendingAcks.Clear();
+            NeedAcks.Clear();
+         }
 
         /// <summary>
         /// Gets information about this client connection
@@ -302,9 +315,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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;
-            m_info.targetThrottle = (int)m_throttleClient.TargetDripRate;
-            m_info.maxThrottle = (int)m_throttleClient.MaxDripRate;
-
             return m_info;
         }
 
@@ -341,8 +351,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="throttleType"></param>
         public int GetPacketsQueuedCount(ThrottleOutPacketType throttleType)
         {
-            if ((int)throttleType > 0)
-                return m_packetOutboxes[(int)throttleType].Count;
+            int icat = (int)throttleType;
+            if (icat > 0 && icat < THROTTLE_CATEGORY_COUNT)
+                return m_packetOutboxes[icat].Count;
             else
                 return 0;
         }
@@ -359,7 +370,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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,                                 
+                PacketsReceived,
                 PacketsSent,
                 PacketsResent,
                 UnackedBytes,
@@ -379,16 +390,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 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;
 
@@ -408,24 +425,21 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
 
             // 0.125f converts from bits to bytes
-            int resend = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
-            int land = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
-            int wind = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
-            int cloud = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
-            int task = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
-            int texture = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
-            int asset = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f);
+            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);
+
 
-            if (ThrottleDebugLevel > 0)
-            {
-                long total = resend + land + wind + cloud + task + texture + asset;
-                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);
-            }
 
             // 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);
@@ -433,52 +447,54 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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;
+
+            int total = resend + land + wind + cloud + task + texture + asset;
+
+            float m_burst = total * m_burstTime;
 
             if (ThrottleDebugLevel > 0)
             {
-                long total = resend + land + wind + cloud + task + texture + asset;
                 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);
             }
 
-            // Update the token buckets with new throttle values
-            if (m_throttleClient.AdaptiveEnabled)
-            {
-                long total = resend + land + wind + cloud + task + texture + asset;
-                m_throttleClient.TargetDripRate = 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;
@@ -496,25 +512,27 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 int i = 0;
 
                 // multiply by 8 to convert bytes back to bits
-                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Resend].RequestedDripRate * 8 * multiplier;
+                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 * 8 * multiplier;
+                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 * 8 * multiplier;
+                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 * 8 * multiplier;
+                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 * 8 * multiplier;
+                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 * 8 * multiplier;
+                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 * 8 * multiplier;
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Asset].RequestedDripRate * multiplier;
                 Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
 
                 m_packedThrottles = data;
@@ -523,43 +541,65 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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, 
+        /// 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)
             {
-                OpenSim.Framework.LocklessQueue<OutgoingPacket> queue = m_packetOutboxes[category];
+                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 there is already a packet waiting in the queue
-                // even if we have the tokens to send it, tokens should go to the already
-                // queued packets
-                if (queue.Count > 0)
+                // Don't send this packet if queue is not empty
+                if (queue.Count > 0 || m_nextPackets[category] != null)
                 {
-                    queue.Enqueue(packet);
+                    queue.Enqueue(packet, highPriority);
                     return true;
                 }
-                
-                    
-                if (!forceQueue && bucket.RemoveTokens(packet.Buffer.DataLength))
+
+                if (!forceQueue && bucket.CheckTokens(packet.Buffer.DataLength))
                 {
-                    // Enough tokens were removed from the bucket, the packet will not be queued
+                    // 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);
+                    queue.Enqueue(packet, highPriority);
                     return true;
                 }
             }
@@ -568,28 +608,31 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 // 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 
+        /// 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()
         {
-            OutgoingPacket packet;
-            OpenSim.Framework.LocklessQueue<OutgoingPacket> queue;
+//            if (m_deliverPackets == false) return false;
+
+            OutgoingPacket packet = null;
+            DoubleLocklessQueue<OutgoingPacket> queue;
             TokenBucket bucket;
             bool packetSent = false;
             ThrottleOutPacketTypeFlags emptyCategories = 0;
@@ -613,6 +656,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         m_udpServer.SendPacketFinal(nextPacket);
                         m_nextPackets[i] = null;
                         packetSent = true;
+
+                        if (m_packetOutboxes[i].Count < 5)
+                            emptyCategories |= CategoryToFlag(i);
                     }
                 }
                 else
@@ -620,32 +666,47 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     // No dequeued packet waiting to be sent, try to pull one off
                     // this queue
                     queue = m_packetOutboxes[i];
-                    if (queue.Dequeue(out packet))
+                    if (queue != null)
                     {
-                        // 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))
+                        bool success = false;
+                        try
                         {
-                            // Send the packet
-                            m_udpServer.SendPacketFinal(packet);
-                            packetSent = true;
+                            success = queue.Dequeue(out packet);
                         }
-                        else
+                        catch
                         {
-                            // Save the dequeued packet for the next iteration
-                            m_nextPackets[i] = packet;
+                            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;
+                            }
 
-                        // If the queue is empty after this dequeue, fire the queue
-                        // empty callback now so it has a chance to fill before we 
-                        // get back here
-                        if (queue.Count == 0)
+                        }
+                        else
+                        {
+                            // No packets in this queue. Fire the queue empty callback
+                            // if it has not been called recently
                             emptyCategories |= CategoryToFlag(i);
+                        }
                     }
                     else
                     {
-                        // No packets in this queue. Fire the queue empty callback
-                        // if it has not been called recently
+                        m_packetOutboxes[i] = new DoubleLocklessQueue<OutgoingPacket>();
                         emptyCategories |= CategoryToFlag(i);
                     }
                 }
@@ -712,6 +773,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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
@@ -719,44 +783,27 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="categories">Throttle categories to fire the callback for</param>
         private void BeginFireQueueEmpty(ThrottleOutPacketTypeFlags categories)
         {
-//            if (m_nextOnQueueEmpty != 0 && (Environment.TickCount & Int32.MaxValue) >= m_nextOnQueueEmpty)
-            if (!m_isQueueEmptyRunning && (Environment.TickCount & Int32.MaxValue) >= m_nextOnQueueEmpty)
+            if (!m_isQueueEmptyRunning)
             {
-                m_isQueueEmptyRunning = true;
+                if (!HasUpdates(categories))
+                    return;
 
-                int start = Environment.TickCount & Int32.MaxValue;
-                const int MIN_CALLBACK_MS = 30;
+                double start = Util.GetTimeStampMS();
+                if (start < m_nextOnQueueEmpty)
+                    return;
 
+                m_isQueueEmptyRunning = true;
                 m_nextOnQueueEmpty = start + MIN_CALLBACK_MS;
-                if (m_nextOnQueueEmpty == 0)
-                    m_nextOnQueueEmpty = 1;
 
-                // Use a value of 0 to signal that FireQueueEmpty is running
-//                m_nextOnQueueEmpty = 0;
-
-                m_categories = categories;
-
-                if (HasUpdates(m_categories))
-                {
-                    if (!m_udpServer.OqrEngine.IsRunning)
-                    {
-                        // Asynchronously run the callback
-                        Util.FireAndForget(FireQueueEmpty, categories, "LLUDPClient.BeginFireQueueEmpty");
-                    }
-                    else
-                    {
-                        m_udpServer.OqrEngine.QueueJob(AgentID.ToString(), () => FireQueueEmpty(categories));
-                    }
-                }
+                // Asynchronously run the callback
+                if (m_udpServer.OqrEngine.IsRunning)
+                    m_udpServer.OqrEngine.QueueJob(AgentID.ToString(), () => FireQueueEmpty(categories));
                 else
-                {
-                    m_isQueueEmptyRunning = false;
-                }
+                    Util.FireAndForget(FireQueueEmpty, categories, "LLUDPClient.BeginFireQueueEmpty");
             }
         }
 
-        private bool m_isQueueEmptyRunning;
-        private ThrottleOutPacketTypeFlags m_categories = 0;
+
 
         /// <summary>
         /// Fires the OnQueueEmpty callback and sets the minimum time that it
@@ -767,33 +814,33 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// signature</param>
         public void FireQueueEmpty(object o)
         {
-//            m_log.DebugFormat("[LLUDPCLIENT]: FireQueueEmpty for {0} in {1}", AgentID, m_udpServer.Scene.Name);
-
-//            int start = Environment.TickCount & Int32.MaxValue;
-//            const int MIN_CALLBACK_MS = 30;
+            ThrottleOutPacketTypeFlags categories = (ThrottleOutPacketTypeFlags)o;
+            QueueEmpty callback = OnQueueEmpty;
 
-//            if (m_udpServer.IsRunningOutbound)
-//            {        
-                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); }
-//                    }
-                }
-//            }
+            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_nextOnQueueEmpty = start + MIN_CALLBACK_MS;
-//            if (m_nextOnQueueEmpty == 0)
-//                m_nextOnQueueEmpty = 1;
+            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);
+        }
 
-            m_isQueueEmptyRunning = false;
+        internal int GetThrottleSetting(int throttle)
+        {
+            if (throttle > 0 && throttle < THROTTLE_CATEGORY_COUNT)
+                return (int)m_throttleCategories[throttle].RequestedDripRate;
+            else
+                return 0;
         }
 
         /// <summary>
@@ -839,4 +886,33 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
     }
+
+    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
index 4528714..b575ed9 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
@@ -51,60 +51,59 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     /// A shim around LLUDPServer that implements the IClientNetworkServer interface
     /// </summary>
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "LLUDPServerShim")]
-    public sealed class LLUDPServerShim : INonSharedRegionModule
+    public class LLUDPServerShim : INonSharedRegionModule
     {
-        private bool m_Enabled = true;
-        private IConfigSource m_Config;
-        LLUDPServer m_udpServer;
+        protected IConfigSource m_Config;
+        protected LLUDPServer m_udpServer;
 
         #region INonSharedRegionModule
-        public string Name
+        public virtual string Name
         {
             get { return "LLUDPServerShim"; }
         }
 
-        public Type ReplaceableInterface
+        public virtual Type ReplaceableInterface
         {
             get { return null; }
         }
 
-        public void Initialise(IConfigSource source)
+        public virtual void Initialise(IConfigSource source)
         {
             m_Config = source;
         }
 
-        public void Close()
+        public virtual void Close()
         {
         }
 
-        public void AddRegion(Scene scene)
+        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, scene.RegionInfo.m_allow_alternate_ports, m_Config, scene.AuthenticateHandler);
+            Initialise(listenIP, ref port, scene.RegionInfo.ProxyOffset, m_Config, scene.AuthenticateHandler);
             scene.RegionInfo.InternalEndPoint.Port = (int)port;
 
             AddScene(scene);
         }
 
-        public void RemoveRegion(Scene scene)
+        public virtual void RemoveRegion(Scene scene)
         {
             Stop();
         }
 
-        public void RegionLoaded(Scene scene)
+        public virtual void RegionLoaded(Scene scene)
         {
             Start();
         }
         #endregion
 
-        public void Initialise(IPAddress listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port, IConfigSource configSource, AgentCircuitManager circuitManager)
+        public virtual void Initialise(IPAddress listenIP, ref uint port, int proxyPortOffsetParm, IConfigSource configSource, AgentCircuitManager circuitManager)
         {
-            m_udpServer = new LLUDPServer(listenIP, ref port, proxyPortOffsetParm, allow_alternate_port, configSource, circuitManager);
+            m_udpServer = new LLUDPServer(listenIP, ref port, proxyPortOffsetParm, configSource, circuitManager);
         }
 
-        public void AddScene(IScene scene)
+        public virtual void AddScene(IScene scene)
         {
             m_udpServer.AddScene(scene);
 
@@ -223,22 +222,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     StatType.Pull,
                     MeasuresOfInterest.None,
                     stat => stat.Value = m_udpServer.AverageReceiveTicksForLastSamplePeriod,
-//                    stat => 
+//                    stat =>
 //                        stat.Value = Math.Round(m_udpServer.AverageReceiveTicksForLastSamplePeriod, 7),
                     StatVerbosity.Debug));
         }
 
-        public bool HandlesRegion(Location x)
+        public virtual bool HandlesRegion(Location x)
         {
             return m_udpServer.HandlesRegion(x);
         }
 
-        public void Start()
+        public virtual void Start()
         {
             m_udpServer.Start();
         }
 
-        public void Stop()
+        public virtual void Stop()
         {
             m_udpServer.Stop();
         }
@@ -257,7 +256,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public const int MTU = 1400;
 
         /// <summary>Number of forced client logouts due to no receipt of packets before timeout.</summary>
-        public int ClientLogoutsDueToNoReceives { get; private set; }
+        public int ClientLogoutsDueToNoReceives { get; protected set; }
 
         /// <summary>
         /// Default packet debug level given to new clients
@@ -273,7 +272,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <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 
+        /// <summary>Number of prim updates to put on the queue each time the
         /// OnQueueEmpty event is triggered for updates</summary>
         public readonly int PrimUpdatesPerCallback;
 
@@ -284,54 +283,53 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>Handlers for incoming packets</summary>
         //PacketEventDictionary packetEvents = new PacketEventDictionary();
         /// <summary>Incoming packets that are awaiting handling</summary>
-        private OpenMetaverse.BlockingQueue<IncomingPacket> packetInbox = new OpenMetaverse.BlockingQueue<IncomingPacket>();
+        //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; private set; }
-        
+        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; private set; }
-        
+        public ThrottleRates ThrottleRates { get; protected set; }
+
         /// <summary>Manages authentication for agent circuits</summary>
-        private AgentCircuitManager m_circuitManager;
+        protected AgentCircuitManager m_circuitManager;
 
         /// <summary>Reference to the scene this UDP server is attached to</summary>
-        public Scene Scene { get; private set; }
+        public Scene Scene { get; protected set; }
 
         /// <summary>The X/Y coordinates of the scene this UDP server is attached to</summary>
-        private Location m_location;
+        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>
-        private int m_recvBufferSize;
-
-        /// <summary>Flag to process packets asynchronously or synchronously</summary>
-        private bool m_asyncPacketHandling;
+        protected int m_recvBufferSize;
 
         /// <summary>Tracks whether or not a packet was sent each round so we know
         /// whether or not to sleep</summary>
-        private bool m_packetSent;
+        protected bool m_packetSent;
 
         /// <summary>Environment.TickCount of the last time that packet stats were reported to the scene</summary>
-        private int m_elapsedMSSinceLastStatReport = 0;
+        protected int m_elapsedMSSinceLastStatReport = 0;
 
         /// <summary>Environment.TickCount of the last time the outgoing packet handler executed</summary>
-        private int m_tickLastOutgoingPacketHandler;
+        protected double m_tickLastOutgoingPacketHandler;
 
         /// <summary>Keeps track of the number of elapsed milliseconds since the last time the outgoing packet handler looped</summary>
-        private int m_elapsedMSOutgoingPacketHandler;
+        protected double m_elapsedMSOutgoingPacketHandler;
 
         /// <summary>Keeps track of the number of 100 millisecond periods elapsed in the outgoing packet handler executed</summary>
-        private int m_elapsed100MSOutgoingPacketHandler;
+        protected int m_elapsed100MSOutgoingPacketHandler;
 
         /// <summary>Keeps track of the number of 500 millisecond periods elapsed in the outgoing packet handler executed</summary>
-        private int m_elapsed500MSOutgoingPacketHandler;
+        protected int m_elapsed500MSOutgoingPacketHandler;
 
         /// <summary>Flag to signal when clients should check for resends</summary>
         protected bool m_resendUnacked;
@@ -342,32 +340,38 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>Flag to signal when clients should send pings</summary>
         protected bool m_sendPing;
 
-        /// <summary>
-        /// Event used to signal when queued packets are available for sending.
-        /// </summary>
-        /// <remarks>
-        /// This allows the outbound loop to only operate when there is data to send rather than continuously polling.
-        /// Some data is sent immediately and not queued.  That data would not trigger this event.
-        /// </remarks>
-        private AutoResetEvent m_dataPresentEvent = new AutoResetEvent(false);
+        protected int m_animationSequenceNumber;
 
-        private Pool<IncomingPacket> m_incomingPacketPool;
+        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>
-        private Stat m_poolCountStat;
+        protected Stat m_poolCountStat;
 
         /// <summary>
         /// Stat for number of packets in the inbound packet pool awaiting use.
         /// </summary>
-        private Stat m_incomingPacketPoolStat;
+        protected Stat m_incomingPacketPoolStat;
 
-        private int m_defaultRTO = 0;
-        private int m_maxRTO = 0;
-        private int m_ackTimeout = 0;
-        private int m_pausedAckTimeout = 0;
-        private bool m_disableFacelights = false;
+        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; } }
 
@@ -389,28 +393,28 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>
         /// Record how many inbound packets could not be recognized as LLUDP packets.
         /// </summary>
-        public int IncomingMalformedPacketCount { get; private set; }
+        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; private set; }
+        public int IncomingOrphanedPacketCount { get; protected set; }
 
         /// <summary>
         /// Record current outgoing client for monitoring purposes.
         /// </summary>
-        private IClientAPI m_currentOutgoingClient;
+        protected IClientAPI m_currentOutgoingClient;
 
         /// <summary>
         /// Recording current incoming client for monitoring purposes.
         /// </summary>
-        private IClientAPI m_currentIncomingClient;
+        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; private set; }
+//        public JobEngine IpahEngine { get; protected set; }
 
         /// <summary>
         /// Run queue empty processing within a single persistent thread.
@@ -420,27 +424,42 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// connection schedule its own job in the threadpool which causes performance problems when there are many
         /// connections.
         /// </remarks>
-        public JobEngine OqrEngine { get; private set; }
+        public JobEngine OqrEngine { get; protected set; }
 
         public LLUDPServer(
-            IPAddress listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port,
+            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 < 5; i++)
+            for (int i = 0; i < 10; i++)
             {
                 int start = Environment.TickCount;
                 int now = start;
                 while (now == start)
                     now = Environment.TickCount;
-                TickCountResolution += (float)(now - start) * 0.2f;
+                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));
             }
-            m_log.Info("[LLUDPSERVER]: Average Environment.TickCount resolution: " + TickCountResolution + "ms");
-            TickCountResolution = (float)Math.Ceiling(TickCountResolution);
+
+            TickCountResolution = (float)Math.Round(TickCountResolution * 0.01f,6,MidpointRounding.AwayFromZero);
+            m_log.Info("[LLUDPSERVER]: Average Util.GetTimeStampMS resolution: " + TickCountResolution + "ms");
 
             #endregion Environment.TickCount Measurement
 
@@ -451,7 +470,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             IConfig config = configSource.Configs["ClientStack.LindenUDP"];
             if (config != null)
             {
-                m_asyncPacketHandling = config.GetBoolean("async_packet_handling", true);
                 m_recvBufferSize = config.GetInt("client_socket_rcvbuf_size", 0);
                 sceneThrottleBps = config.GetInt("scene_throttle_max_bps", 0);
 
@@ -494,24 +512,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             #endregion BinaryStats
 
-            // FIXME: Can't add info here because don't know scene yet.
-//            m_throttle 
-//                = new TokenBucket(
-//                    string.Format("server throttle bucket for {0}", Scene.Name), null, sceneThrottleBps);
-
-            Throttle = new TokenBucket("server throttle bucket", null, 0, sceneThrottleBps);
-
+            Throttle = new TokenBucket(null, sceneThrottleBps, sceneThrottleBps * 10e-3f);
             ThrottleRates = new ThrottleRates(configSource);
 
-            if (usePools)
-                EnablePools();
+            Random rnd = new Random(Util.EnvironmentTickCount());
+            m_animationSequenceNumber = rnd.Next(11474826);
+
+//            if (usePools)
+//                EnablePools();
+            base.DisablePools();
         }
 
         public void Start()
         {
             StartInbound();
             StartOutbound();
-            IpahEngine.Start();
+//            IpahEngine.Start();
             OqrEngine.Start();
 
             m_elapsedMSSinceLastStatReport = Environment.TickCount;
@@ -520,10 +536,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public void StartInbound()
         {
             m_log.InfoFormat(
-                "[LLUDPSERVER]: Starting inbound packet processing for the LLUDP server in {0} mode with UsePools = {1}",
-                m_asyncPacketHandling ? "asynchronous" : "synchronous", UsePools);
+                "[LLUDPSERVER]: Starting inbound packet processing for the LLUDP server");
 
-            base.StartInbound(m_recvBufferSize, m_asyncPacketHandling);
+            base.StartInbound(m_recvBufferSize);
 
             // This thread will process the packets received that are placed on the packetInbox
             WorkManager.StartThread(
@@ -557,7 +572,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_log.Info("[LLUDPSERVER]: Shutting down the LLUDP server for " + Scene.Name);
             base.StopOutbound();
             base.StopInbound();
-            IpahEngine.Stop();
+//            IpahEngine.Stop();
             OqrEngine.Stop();
         }
 
@@ -642,7 +657,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// If the outgoing UDP thread times out, then return client that was being processed to help with debugging.
         /// </summary>
         /// <returns></returns>
-        private string GetWatchdogIncomingAlarmData()
+        protected string GetWatchdogIncomingAlarmData()
         {
             return string.Format(
                 "Client is {0}",
@@ -653,7 +668,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// If the outgoing UDP thread times out, then return client that was being processed to help with debugging.
         /// </summary>
         /// <returns></returns>
-        private string GetWatchdogOutgoingAlarmData()
+        protected string GetWatchdogOutgoingAlarmData()
         {
             return string.Format(
                 "Client is {0}",
@@ -676,15 +691,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             Scene = (Scene)scene;
             m_location = new Location(Scene.RegionInfo.RegionHandle);
-                        
-            IpahEngine 
+/*
+            IpahEngine
                 = new JobEngine(
-                    string.Format("Incoming Packet Async Handling Engine ({0})", Scene.Name), 
+                    string.Format("Incoming Packet Async Handling Engine ({0})", Scene.Name),
                     "INCOMING PACKET ASYNC HANDLING ENGINE");
-
-            OqrEngine 
+*/
+            OqrEngine
                 = new JobEngine(
-                    string.Format("Outgoing Queue Refill Engine ({0})", Scene.Name), 
+                    string.Format("Outgoing Queue Refill Engine ({0})", Scene.Name),
                     "OUTGOING QUEUE REFILL ENGINE");
 
             StatsManager.RegisterStat(
@@ -697,7 +712,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     scene.Name,
                     StatType.Pull,
                     MeasuresOfInterest.AverageChangeOverTime,
-                    stat => stat.Value = packetInbox.Count,
+                    stat => stat.Value = packetInbox.Count(),
                     StatVerbosity.Debug));
 
             // XXX: These stats are also pool stats but we register them separately since they are currently not
@@ -710,9 +725,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     "clientstack",
                     Scene.Name,
                     StatType.Pull,
-                    stat => 
-                        { PercentageStat pstat = (PercentageStat)stat; 
-                          pstat.Consequent = PacketPool.Instance.PacketsRequested; 
+                    stat =>
+                        { PercentageStat pstat = (PercentageStat)stat;
+                          pstat.Consequent = PacketPool.Instance.PacketsRequested;
                           pstat.Antecedent = PacketPool.Instance.PacketsReused; },
                     StatVerbosity.Debug));
 
@@ -725,8 +740,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     Scene.Name,
                     StatType.Pull,
                     stat =>
-                        { PercentageStat pstat = (PercentageStat)stat; 
-                          pstat.Consequent = PacketPool.Instance.BlocksRequested; 
+                        { PercentageStat pstat = (PercentageStat)stat;
+                          pstat.Consequent = PacketPool.Instance.BlocksRequested;
                           pstat.Antecedent = PacketPool.Instance.BlocksReused; },
                     StatVerbosity.Debug));
 
@@ -766,7 +781,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     MeasuresOfInterest.AverageChangeOverTime,
                     stat => stat.Value = GetTotalQueuedOutgoingPackets(),
                     StatVerbosity.Info));
-
+/*
             StatsManager.RegisterStat(
                 new Stat(
                     "IncomingPacketAsyncRequestsWaiting",
@@ -779,7 +794,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     MeasuresOfInterest.None,
                     stat => stat.Value = IpahEngine.JobsWaiting,
                     StatVerbosity.Debug));
-                        
+*/
             StatsManager.RegisterStat(
                 new Stat(
                     "OQRERequestsWaiting",
@@ -792,14 +807,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     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)
@@ -906,9 +923,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
 
             PacketPool.Instance.ReturnPacket(packet);
-
-            if (packetQueued)
-                m_dataPresentEvent.Set();
         }
 
         /// <summary>
@@ -969,8 +983,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     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 + ". Dropping packet");
+                    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);
                 }
             }
@@ -979,35 +993,32 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             #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 
+            // 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 forceQueue = (type == PacketType.KillObject);
 
-//            if (type == PacketType.ImprovedTerseObjectUpdate)
-//            {
-//                m_log.DebugFormat("Direct send ITOU to {0} in {1}", udpClient.AgentID, Scene.Name);
-//                SendPacketFinal(outgoingPacket);
-//                return false;
-//            }
-//            else
-//            {
-            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket, forceQueue))
+            bool requestQueue = type == PacketType.KillObject;
+            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket, requestQueue, highPriority))
             {
                 SendPacketFinal(outgoingPacket);
                 return true;
             }
-            else
-            {
-                return false;
-            }
-//            }
+
+            return false;
 
             #endregion Queue or Send
         }
@@ -1048,6 +1059,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             pc.PingID.OldestUnacked = 0;
 
             SendPacket(udpClient, pc, ThrottleOutPacketType.Unknown, false, null);
+            udpClient.m_lastStartpingTimeMS = Util.EnvironmentTickCount();
         }
 
         public void CompletePing(LLUDPClient udpClient, byte pingID)
@@ -1145,7 +1157,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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)
+            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
@@ -1180,7 +1192,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 Utils.UIntToBytesBig(sequenceNumber, buffer.Data, 1);
                 outgoingPacket.SequenceNumber = sequenceNumber;
 
-                if (udpClient.ProcessUnackedSends && isReliable)
+                if (isReliable)
                 {
                     // Add this packet to the list of ACK responses we are waiting on from the server
                     udpClient.NeedAcks.Add(outgoingPacket);
@@ -1210,13 +1222,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     outgoingPacket.SequenceNumber, isReliable, isResend, udpClient.AgentID, Scene.Name);
 
             // Put the UDP payload on the wire
-            AsyncBeginSend(buffer);
+//            AsyncBeginSend(buffer);
+            SyncSend(buffer);
 
             // Keep track of when this packet was sent out (right now)
             outgoingPacket.TickCount = Environment.TickCount & Int32.MaxValue;
         }
 
-        private void RecordMalformedInboundPacket(IPEndPoint endPoint)
+        protected void RecordMalformedInboundPacket(IPEndPoint endPoint)
         {
 //                if (m_malformedCount < 100)
 //                    m_log.DebugFormat("[LLUDPSERVER]: Dropped malformed packet: " + e.ToString());
@@ -1225,7 +1238,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             if ((IncomingMalformedPacketCount % 10000) == 0)
                 m_log.WarnFormat(
-                    "[LLUDPSERVER]: Received {0} malformed packets so far, probable network attack.  Last was from {1}", 
+                    "[LLUDPSERVER]: Received {0} malformed packets so far, probable network attack.  Last was from {1}",
                     IncomingMalformedPacketCount, endPoint);
         }
 
@@ -1311,35 +1324,62 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             #region Packet to Client Mapping
 
-            // UseCircuitCode handling
-            if (packet.Type == PacketType.UseCircuitCode)
+            // 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))
             {
-                // 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 };
+                // 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;
 
-                Util.FireAndForget(HandleUseCircuitCode, array, "LLUDPServer.HandleUseCircuitCode");
+                        m_pendingCache.AddOrUpdate(endPoint, new Queue<UDPPacketBuffer>(), 60);
+                    }
 
-                return;
+                    // 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;
+                }
             }
-            else if (packet.Type == PacketType.CompleteAgentMovement)
+
+            // If this is a pending connection, enqueue, don't process yet
+            lock (m_pendingCache)
             {
-                // Send ack straight away to let the viewer know that we got it.
-                SendAckImmediate(endPoint, packet.Header.Sequence);
+                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;
+                }
 
-                // 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 };
+/*
+                else if (packet.Type == PacketType.CompleteAgentMovement)
+                {
+                    // Send ack straight away to let the viewer know that we got it.
+                    SendAckImmediate(endPoint, packet.Header.Sequence);
 
-                Util.FireAndForget(
-                    HandleCompleteMovementIntoRegion, array, "LLUDPServer.HandleCompleteMovementIntoRegion");
+                    // 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 };
 
-                return;
+                    Util.FireAndForget(HandleCompleteMovementIntoRegion, array);
+
+                    return;
+                }
+ */
             }
 
             // Determine which agent this packet came from
-            IClientAPI client;
-            if (!Scene.TryGetClient(endPoint, out client) || !(client is LLClientView))
+            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);
 
@@ -1347,7 +1387,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 if ((IncomingOrphanedPacketCount % 10000) == 0)
                     m_log.WarnFormat(
-                        "[LLUDPSERVER]: Received {0} orphaned packets so far.  Last was from {1}", 
+                        "[LLUDPSERVER]: Received {0} orphaned packets so far.  Last was from {1}",
                         IncomingOrphanedPacketCount, endPoint);
 
                 return;
@@ -1356,7 +1396,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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
 
@@ -1368,37 +1411,30 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             #region ACK Receiving
 
-            if (udpClient.ProcessUnackedSends)
+            // Handle appended ACKs
+            if (packet.Header.AppendedAcks && packet.Header.AckList != null)
             {
-                // 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);
+                // 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);
-                }
+                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;
+            // 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);
+                // 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);
+                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;
-                }
-            }
-            else if (packet.Type == PacketType.PacketAck)
-            {
+                // We don't need to do anything else with PacketAck packets
                 return;
             }
 
@@ -1442,7 +1478,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 if (packet.Header.Resent)
                     m_log.DebugFormat(
-                        "[LLUDPSERVER]: Received a resend of already processed packet #{0}, type {1} from {2}", 
+                        "[LLUDPSERVER]: Received a resend of already processed packet #{0}, type {1} from {2}",
                         packet.Header.Sequence, packet.Type, client.Name);
                  else
                     m_log.WarnFormat(
@@ -1459,24 +1495,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             LogPacketHeader(true, udpClient.CircuitCode, 0, packet.Type, (ushort)packet.Length);
             #endregion BinaryStats
 
-            if (packet.Type == PacketType.AgentUpdate)
-            {
-                if (DiscardInboundAgentUpdates)
-                    return;
 
-                ((LLClientView)client).TotalAgentUpdates++;
+//AgentUpdate removed from here
 
-                AgentUpdatePacket agentUpdate = (AgentUpdatePacket)packet;
-
-                LLClientView llClient = client as LLClientView;
-                if (agentUpdate.AgentData.SessionID != client.SessionId 
-                    || agentUpdate.AgentData.AgentID != client.AgentId
-                    || !(llClient == null || llClient.CheckAgentUpdateSignificance(agentUpdate.AgentData)) )
-                {
-                    PacketPool.Instance.ReturnPacket(packet);
-                    return;
-                }
-            }
 
             #region Ping Check Handling
 
@@ -1497,7 +1518,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             else if (packet.Type == PacketType.CompletePingCheck)
             {
-                // We don't currently track client ping times
+                int t = Util.EnvironmentTickCountSubtract(udpClient.m_lastStartpingTimeMS);
+                int c = udpClient.m_pingMS;
+                c = 800 * c + 200 * t;
+                c /= 1000;
+                udpClient.m_pingMS = c;
                 return;
             }
 
@@ -1517,7 +1542,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 incomingPacket = new IncomingPacket((LLClientView)client, packet);
             }
 
-            packetInbox.Enqueue(incomingPacket);
+//            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
@@ -1627,14 +1658,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         #endregion BinaryStats
 
-        private void HandleUseCircuitCode(object o)
+        protected void HandleUseCircuitCode(object o)
         {
             IPEndPoint endPoint = null;
             IClientAPI client = null;
 
             try
             {
-    //            DateTime startTime = DateTime.Now;
+//              DateTime startTime = DateTime.Now;
                 object[] array = (object[])o;
                 endPoint = (IPEndPoint)array[0];
                 UseCircuitCodePacket uccp = (UseCircuitCodePacket)array[1];
@@ -1642,10 +1673,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 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(
@@ -1654,20 +1687,55 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             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)
                     {
-                        AgentCircuitData aCircuit = Scene.AuthenticateHandler.GetAgentCircuitData(uccp.CircuitCode.Code);
                         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.SentInitialDataToClient)
-                            client.SceneAgent.SendInitialDataToClient();
+                        if (!tp)
+                            client.SceneAgent.SendInitialDataToMe();
                     }
                 }
                 else
@@ -1675,11 +1743,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     // 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", 
+    //                "[LLUDPSERVER]: Handling UseCircuitCode request from {0} took {1}ms",
     //                buffer.RemoteEndPoint, (DateTime.Now - startTime).Milliseconds);
 
             }
@@ -1694,8 +1766,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     e.StackTrace);
             }
         }
-
-        private void HandleCompleteMovementIntoRegion(object o)
+/*
+         protected void HandleCompleteMovementIntoRegion(object o)
         {
             IPEndPoint endPoint = null;
             IClientAPI client = null;
@@ -1711,9 +1783,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 // 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 
+                // 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 
+                // packets asynchronously, we need to account for this thread proceeding more quickly than the
                 // UseCircuitCode thread.
                 int count = 40;
                 while (count-- > 0)
@@ -1735,7 +1807,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             // 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 
+                            // 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.",
@@ -1749,7 +1821,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     else
                     {
                         m_log.DebugFormat(
-                            "[LLUDPSERVER]: Received a CompleteAgentMovement from {0} in {1} but no client exists yet.  Waiting.", 
+                            "[LLUDPSERVER]: Received a CompleteAgentMovement from {0} in {1} but no client exists yet.  Waiting.",
                             endPoint, Scene.Name);
                     }
 
@@ -1804,6 +1876,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     e.StackTrace);
             }
         }
+*/
 
         /// <summary>
         /// Send an ack immediately to the given endpoint.
@@ -1814,7 +1887,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// </remarks>
         /// <param name="remoteEndpoint"></param>
         /// <param name="sequenceNumber"></param>
-        private void SendAckImmediate(IPEndPoint remoteEndpoint, uint sequenceNumber)
+        protected void SendAckImmediate(IPEndPoint remoteEndpoint, uint sequenceNumber)
         {
             PacketAckPacket ack = new PacketAckPacket();
             ack.Header.Reliable = false;
@@ -1835,10 +1908,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             Buffer.BlockCopy(packetData, 0, buffer.Data, 0, length);
 
-            AsyncBeginSend(buffer);
+//            AsyncBeginSend(buffer);
+            SyncSend(buffer);
         }
 
-        private bool IsClientAuthorized(UseCircuitCodePacket useCircuitCode, out AuthenticateResponse sessionInfo)
+        protected bool IsClientAuthorized(UseCircuitCodePacket useCircuitCode, out AuthenticateResponse sessionInfo)
         {
             UUID agentID = useCircuitCode.CircuitCode.ID;
             UUID sessionID = useCircuitCode.CircuitCode.SessionID;
@@ -1861,6 +1935,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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
@@ -1869,14 +1944,28 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 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();
                 }
             }
@@ -1893,56 +1982,55 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// </remarks>
         /// <param name='client'></param>
         /// <param name='timeoutTicks'></param>
-        private void DeactivateClientDueToTimeout(LLClientView client, int timeoutTicks)
+        protected void DeactivateClientDueToTimeout(LLClientView client, int timeoutTicks)
         {
             lock (client.CloseSyncLock)
-            {    
+            {
                 ClientLogoutsDueToNoReceives++;
 
-                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 (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.");
+                }
             }
 
-            Scene.CloseAgent(client.AgentId, true);
+            if (!Scene.CloseAgent(client.AgentId, true))
+                client.Close(true,true);
         }
 
-        private void IncomingPacketHandler()
+        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 incomingPacket = null;
-
-                    /*
-                    // HACK: This is a test to try and rate limit packet handling on Mono.
-                    // If it works, a more elegant solution can be devised
-                    if (Util.FireAndForgetCount() < 2)
-                    {
-                        //m_log.Debug("[LLUDPSERVER]: Incoming packet handler is sleeping");
-                        Thread.Sleep(30);
-                    }
-                     */
+                    incomingPacket = packetInbox.Dequeue(250);
 
-                    if (packetInbox.Dequeue(100, ref incomingPacket))
+                    if (incomingPacket != null && IsRunningInbound)
                     {
-                        ProcessInPacket(incomingPacket);//, incomingPacket); Util.FireAndForget(ProcessInPacket, incomingPacket);
+                        ProcessInPacket(incomingPacket);
 
                         if (UsePools)
+                        {
+                            incomingPacket.Client = null;
                             m_incomingPacketPool.ReturnObject(incomingPacket);
+                        }
+                        incomingPacket = null;
                     }
                 }
-                catch (Exception ex)
+                catch(Exception ex)
                 {
                     m_log.Error("[LLUDPSERVER]: Error in the incoming packet handler loop: " + ex.Message, ex);
                 }
@@ -1950,14 +2038,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 Watchdog.UpdateThread();
             }
 
-            if (packetInbox.Count > 0)
-                m_log.Warn("[LLUDPSERVER]: IncomingPacketHandler is shutting down, dropping " + packetInbox.Count + " packets");
+            if (packetInbox.Count() > 0)
+                m_log.Warn("[LLUDPSERVER]: IncomingPacketHandler is shutting down, dropping " + packetInbox.Count() + " packets");
             packetInbox.Clear();
 
             Watchdog.RemoveThread();
         }
 
-        private void OutgoingPacketHandler()
+        protected void OutgoingPacketHandler()
         {
             Thread.CurrentThread.Priority = ThreadPriority.Highest;
 
@@ -1971,6 +2059,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             while (base.IsRunningOutbound)
             {
+                Scene.ThreadAlive(2);
+
+
                 try
                 {
                     m_packetSent = false;
@@ -1982,19 +2073,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     m_sendPing = false;
 
                     // Update elapsed time
-                    int thisTick = Environment.TickCount & Int32.MaxValue;
-                    if (m_tickLastOutgoingPacketHandler > thisTick)
-                        m_elapsedMSOutgoingPacketHandler += ((Int32.MaxValue - m_tickLastOutgoingPacketHandler) + thisTick);
-                    else
-                        m_elapsedMSOutgoingPacketHandler += (thisTick - m_tickLastOutgoingPacketHandler);
+                    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)
+                    if (m_elapsedMSOutgoingPacketHandler >= 100.0)
                     {
                         m_resendUnacked = true;
-                        m_elapsedMSOutgoingPacketHandler = 0;
+                        m_elapsedMSOutgoingPacketHandler = 0.0;
                         m_elapsed100MSOutgoingPacketHandler += 1;
                     }
 
@@ -2012,15 +2101,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         m_sendPing = true;
                         m_elapsed500MSOutgoingPacketHandler = 0;
                     }
-
                     #endregion Update Timers
 
-                    // Use this for emergency monitoring -- bug hunting
-                    //if (m_scene.EmergencyMonitoring)
-                    //    clientPacketHandler = MonitoredClientOutgoingPacketHandler;
-                    //else
-                    //    clientPacketHandler = ClientOutgoingPacketHandler;
-
                     // 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);
@@ -2029,13 +2111,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     // If nothing was sent, sleep for the minimum amount of time before a
                     // token bucket could get more tokens
-                    //if (!m_packetSent)
-                    //    Thread.Sleep((int)TickCountResolution);
-                    //
-                    // Instead, now wait for data present to be explicitly signalled.  Evidence so far is that with
-                    // modern mono it reduces CPU base load since there is no more continuous polling.
-                    if (!m_packetSent)
-                        m_dataPresentEvent.WaitOne(100);
+
+                    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();
                 }
@@ -2061,7 +2144,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     if (udpClient.IsConnected)
                     {
-                        if (udpClient.ProcessUnackedSends && m_resendUnacked)
+                        if (m_resendUnacked)
                             HandleUnacked(llClient);
 
                         if (m_sendAcks)
@@ -2086,160 +2169,61 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         #region Emergency Monitoring
         // Alternative packet handler fuull of instrumentation
         // Handy for hunting bugs
-        private Stopwatch watch1 = new Stopwatch();
-        private Stopwatch watch2 = new Stopwatch();
-
-        private float avgProcessingTicks = 0;
-        private float avgResendUnackedTicks = 0;
-        private float avgSendAcksTicks = 0;
-        private float avgSendPingTicks = 0;
-        private float avgDequeueTicks = 0;
-        private long nticks = 0;
-        private long nticksUnack = 0;
-        private long nticksAck = 0;
-        private long nticksPing = 0;
-        private int npacksSent = 0;
-        private int npackNotSent = 0;
+        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; private set; }
-
-        private void MonitoredClientOutgoingPacketHandler(IClientAPI client)
-        {
-            nticks++;
-            watch1.Start();
-            m_currentOutgoingClient = client;
-
-            try
-            {
-                if (client is LLClientView)
-                {
-                    LLClientView llClient = (LLClientView)client;
-                    LLUDPClient udpClient = llClient.UDPClient;
+        public long IncomingPacketsProcessed { get; protected set; }
 
-                    if (udpClient.IsConnected)
-                    {
-                        if (m_resendUnacked)
-                        {
-                            nticksUnack++;
-                            watch2.Start();
-
-                            HandleUnacked(llClient);
-
-                            watch2.Stop();
-                            avgResendUnackedTicks = (nticksUnack - 1)/(float)nticksUnack * avgResendUnackedTicks + (watch2.ElapsedTicks / (float)nticksUnack);
-                            watch2.Reset();
-                        }
-
-                        if (m_sendAcks)
-                        {
-                            nticksAck++;
-                            watch2.Start();
-                            
-                            SendAcks(udpClient);
-
-                            watch2.Stop();
-                            avgSendAcksTicks = (nticksAck - 1) / (float)nticksAck * avgSendAcksTicks + (watch2.ElapsedTicks / (float)nticksAck);
-                            watch2.Reset();
-                        }
-
-                        if (m_sendPing)
-                        {
-                            nticksPing++;
-                            watch2.Start();
-                            
-                            SendPing(udpClient);
+        #endregion
 
-                            watch2.Stop();
-                            avgSendPingTicks = (nticksPing - 1) / (float)nticksPing * avgSendPingTicks + (watch2.ElapsedTicks / (float)nticksPing);
-                            watch2.Reset();
-                        }
+        protected void ProcessInPacket(IncomingPacket incomingPacket)
+        {
+            Packet packet = incomingPacket.Packet;
+            LLClientView client = incomingPacket.Client;
 
-                        watch2.Start();
-                        // Dequeue any outgoing packets that are within the throttle limits
-                        if (udpClient.DequeueOutgoing())
-                        {
-                            m_packetSent = true;
-                            npacksSent++;
-                        }
-                        else
-                        {
-                            npackNotSent++;
-                        }
+            if(!client.IsActive)
+                return;
 
-                        watch2.Stop();
-                        avgDequeueTicks = (nticks - 1) / (float)nticks * avgDequeueTicks + (watch2.ElapsedTicks / (float)nticks);
-                        watch2.Reset();
+            m_currentIncomingClient = client;
 
-                    }
-                    else
-                    {
-                        m_log.WarnFormat("[LLUDPSERVER]: Client is not connected");
-                    }
-                }
-            }
-            catch (Exception ex)
+            try
             {
-                m_log.Error("[LLUDPSERVER]: OutgoingPacketHandler iteration for " + client.Name +
-                    " threw an exception: " + ex.Message, ex);
+                // Process this packet
+                client.ProcessInPacket(packet);
             }
-            watch1.Stop();
-            avgProcessingTicks = (nticks - 1) / (float)nticks * avgProcessingTicks + (watch1.ElapsedTicks / (float)nticks);
-            watch1.Reset();
-
-            // reuse this -- it's every ~100ms
-            if (Scene.EmergencyMonitoring && nticks % 100 == 0)
+            catch(ThreadAbortException)
             {
-                m_log.InfoFormat("[LLUDPSERVER]: avg processing ticks: {0} avg unacked: {1} avg acks: {2} avg ping: {3} avg dequeue: {4} (TickCountRes: {5} sent: {6} notsent: {7})", 
-                    avgProcessingTicks, avgResendUnackedTicks, avgSendAcksTicks, avgSendPingTicks, avgDequeueTicks, TickCountResolution, npacksSent, npackNotSent);
-                npackNotSent = npacksSent = 0;
+                // 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();
             }
-
-        }
-
-        #endregion 
-
-        private void ProcessInPacket(IncomingPacket incomingPacket)
-        {
-            Packet packet = incomingPacket.Packet;
-            LLClientView client = incomingPacket.Client;
-
-            if (client.IsActive)
+            catch(Exception e)
             {
-                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;
-                }
+                // 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);
             }
-            else
+            finally
             {
-                m_log.DebugFormat(
-                    "[LLUDPSERVER]: Dropped incoming {0} for dead client {1} in {2}",
-                    packet.Type, client.Name, Scene.RegionInfo.RegionName);
+                m_currentIncomingClient = null;
             }
 
             IncomingPacketsProcessed++;
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServerCommands.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServerCommands.cs
index ac6c0b4..012a57d 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServerCommands.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServerCommands.cs
@@ -48,11 +48,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void Register()
         {
+/*
             m_console.Commands.AddCommand(
                 "Comms", false, "show server throttles",
                 "show server throttles",
                 "Show information about server throttles",
-                HandleShowServerThrottlesCommand); 
+                HandleShowServerThrottlesCommand);
 
             m_console.Commands.AddCommand(
                 "Debug", false, "debug lludp packet",
@@ -206,13 +207,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 HandleClientGetCommand);
 
             m_console.Commands.AddCommand(
-                "Debug", 
-                false, 
+                "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)
@@ -224,24 +226,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             ConsoleDisplayList cdl = new ConsoleDisplayList();
             cdl.AddRow("Adaptive throttles", m_udpServer.ThrottleRates.AdaptiveThrottlesEnabled);
 
-            long maxSceneDripRate = m_udpServer.Throttle.MaxDripRate;
+            long maxSceneDripRate = (long)m_udpServer.Throttle.MaxDripRate;
             cdl.AddRow(
-                "Max scene throttle", 
+                "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", 
+                "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();     
+            StringBuilder report = new StringBuilder();
 
             report.AppendFormat(
                 "{0,7} {1,8} {2,7} {3,7} {4,7} {5,7} {6,9} {7,7}\n",
@@ -252,7 +254,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 "Cloud",
                 "Task",
                 "Texture",
-                "Asset");          
+                "Asset");
 
             report.AppendFormat(
                 "{0,7} {1,8} {2,7} {3,7} {4,7} {5,7} {6,9} {7,7}\n",
@@ -263,7 +265,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 "kb/s",
                 "kb/s",
                 "kb/s",
-                "kb/s");     
+                "kb/s");
 
             ThrottleRates throttleRates = udpServer.ThrottleRates;
             report.AppendFormat(
@@ -275,16 +277,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 (throttleRates.Cloud * 8) / 1000,
                 (throttleRates.Task * 8) / 1000,
                 (throttleRates.Texture  * 8) / 1000,
-                (throttleRates.Asset  * 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, 
+                "{0,-" + maxLength +  "}{1,-" + columnPadding + "}",
+                entry.Length > maxLength ? entry.Substring(0, maxLength) : entry,
                 "");
         }
 
@@ -373,7 +375,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 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];
@@ -465,7 +467,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 MainConsole.Instance.OutputFormat(
                     "Usage: debug lludp throttles get [<avatar-first-name> <avatar-last-name>]");
                 return;
-            }           
+            }
 
             string firstName = null;
             string lastName = null;
@@ -489,7 +491,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     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("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());
@@ -505,14 +507,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_console.OutputFormat("Debug settings for {0}", m_udpServer.Scene.Name);
             ConsoleDisplayList cdl = new ConsoleDisplayList();
 
-            long maxSceneDripRate = m_udpServer.Throttle.MaxDripRate;
+            long maxSceneDripRate = (long)m_udpServer.Throttle.MaxDripRate;
             cdl.AddRow(
-                "max-scene-throttle", 
+                "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", 
+                "max-new-client-throttle",
                 maxClientDripRate != 0 ? string.Format("{0} kbps", maxClientDripRate * 8 / 1000) : "unset");
 
             m_console.Output(cdl.ToString());
@@ -527,7 +529,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 MainConsole.Instance.OutputFormat("Usage: debug lludp set <param> <value>");
                 return;
-            }           
+            }
 
             string param = args[3];
             string rawValue = args[4];
@@ -550,12 +552,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             else
             {
-                return; 
+                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)
@@ -582,11 +585,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         m_console.OutputFormat(
                             "Client debug parameters for {0} ({1}) in {2}",
                             sp.Name, sp.IsChildAgent ? "child" : "root", m_udpServer.Scene.Name);
-
-                        ConsoleDisplayList cdl = new ConsoleDisplayList();
-                        cdl.AddRow("process-unacked-sends", udpClient.ProcessUnackedSends);
-
-                        m_console.Output(cdl.ToString());
                     }
                 });
         }
@@ -600,7 +598,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 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];
@@ -609,28 +607,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             if (args.Length == 8)
                 name = string.Format("{0} {1}", args[6], args[7]);
-
-            if (param == "process-unacked-sends")
-            {
-                bool newValue;
-
-                if (!ConsoleUtil.TryParseConsoleBool(MainConsole.Instance, rawValue, out newValue))
-                    return;
-
-                m_udpServer.Scene.ForEachScenePresence(
-                    sp =>
-                    {
-                        if ((name == null || sp.Name == name) && sp.ControllingClient is LLClientView)
-                        {
-                            LLUDPClient udpClient = ((LLClientView)sp.ControllingClient).UDPClient;
-                            udpClient.ProcessUnackedSends = newValue;
-
-                            m_console.OutputFormat("{0} set to {1} for {2} in {3}", param, newValue, sp.Name, m_udpServer.Scene.Name);
-                        }
-                    });
-            }
+            // nothing here now
         }
-
+*/
         private void HandlePacketCommand(string module, string[] args)
         {
             if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)
@@ -718,12 +697,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             string direction = args[3];
             string subCommand = args[4];
-            string packetName = args[5];           
+            string packetName = args[5];
 
             if (subCommand == "add")
             {
                 MainConsole.Instance.OutputFormat(
-                    "Adding packet {0} to {1} drop list for all connections in {2}", 
+                    "Adding packet {0} to {1} drop list for all connections in {2}",
                     direction, packetName, m_udpServer.Scene.Name);
 
                 m_udpServer.Scene.ForEachScenePresence(
@@ -741,7 +720,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             else if (subCommand == "remove")
             {
                 MainConsole.Instance.OutputFormat(
-                    "Removing packet {0} from {1} drop list for all connections in {2}", 
+                    "Removing packet {0} from {1} drop list for all connections in {2}",
                     direction, packetName, m_udpServer.Scene.Name);
 
                 m_udpServer.Scene.ForEachScenePresence(
@@ -889,10 +868,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 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}", 
+                    "Requests waiting: {0}",
                     m_udpServer.OqrEngine.IsRunning ? m_udpServer.OqrEngine.JobsWaiting.ToString() : "n/a");
             }
-            else 
+            else
             {
                 MainConsole.Instance.OutputFormat("Unrecognized OQRE subcommand {0}", subCommand);
             }
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
index f62dc15..f362b06 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
@@ -3,25 +3,25 @@
  * Original Author: Jeff Cesnik
  * All rights reserved.
  *
- * - Redistribution and use in source and binary forms, with or without 
+ * - 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 
+ * - 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 
+ * 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.
  */
 
@@ -57,9 +57,6 @@ namespace OpenMetaverse
         /// <summary>UDP socket, used in either client or server mode</summary>
         private Socket m_udpSocket;
 
-        /// <summary>Flag to process packets asynchronously or synchronously</summary>
-        private bool m_asyncPacketHandling;
-
         /// <summary>
         /// Are we to use object pool(s) to reduce memory churn when receiving data?
         /// </summary>
@@ -107,13 +104,18 @@ namespace OpenMetaverse
         /// </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
@@ -132,7 +134,7 @@ namespace OpenMetaverse
         /// </summary>
         private int m_dropLastTick = 0;
         private int m_dropResetTicks = 500;
-        
+
         /// <summary>
         /// Debugging code used to simulate dropped packets with bursts
         /// </summary>
@@ -179,11 +181,16 @@ namespace OpenMetaverse
             // 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 
+        /// <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
@@ -195,10 +202,8 @@ namespace OpenMetaverse
         /// 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, bool asyncPacketHandling)
+        public virtual void StartInbound(int recvBufferSize)
         {
-            m_asyncPacketHandling = asyncPacketHandling;
-
             if (!IsRunningInbound)
             {
                 m_log.DebugFormat("[UDPBASE]: Starting inbound UDP loop");
@@ -206,10 +211,6 @@ namespace OpenMetaverse
                 const int SIO_UDP_CONNRESET = -1744830452;
 
                 IPEndPoint ipep = new IPEndPoint(m_localBindAddress, m_udpPort);
-                
-                m_log.DebugFormat(
-                    "[UDPBASE]: Binding UDP listener using internal IP address config {0}:{1}", 
-                    ipep.Address, ipep.Port);                
 
                 m_udpSocket = new Socket(
                     AddressFamily.InterNetwork,
@@ -227,14 +228,23 @@ namespace OpenMetaverse
                 {
                     m_log.Debug("[UDPBASE]: Failed to increase default TTL");
                 }
+
                 try
                 {
-                    // This udp socket flag is not supported under mono, 
+                    // This udp socket flag is not supported under mono,
                     // so we'll catch the exception and continue
-                    m_udpSocket.IOControl(SIO_UDP_CONNRESET, new byte[] { 0 }, null);
-                    m_log.Debug("[UDPBASE]: SIO_UDP_CONNRESET flag set");
+                    // 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 (SocketException)
+                catch
                 {
                     m_log.Debug("[UDPBASE]: SIO_UDP_CONNRESET flag not supported on this platform, ignoring");
                 }
@@ -243,13 +253,22 @@ namespace OpenMetaverse
                 // 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.
-                m_udpSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, false);
+                //
+                // 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
@@ -319,7 +338,7 @@ namespace OpenMetaverse
         {
             UDPPacketBuffer buf;
 
-            // FIXME: Disabled for now as this causes issues with reused packet objects interfering with each other 
+            // 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)
@@ -372,8 +391,8 @@ namespace OpenMetaverse
                         m_log.Warn("[UDPBASE]: Salvaged the UDP listener on port " + m_udpPort);
                     }
                 }
-                catch (ObjectDisposedException e) 
-                { 
+                catch (ObjectDisposedException e)
+                {
                     m_log.Error(
                         string.Format("[UDPBASE]: Error processing UDP begin receive {0}.  Exception  ", UdpReceives), e);
                 }
@@ -392,12 +411,7 @@ namespace OpenMetaverse
             if (IsRunningInbound)
             {
                 UdpReceives++;
-
-                // Asynchronous mode will start another receive before the
-                // callback for this packet is even fired. Very parallel :-)
-                if (m_asyncPacketHandling)
-                    AsyncBeginReceive();
-
+ 
                 try
                 {
                     // get the buffer that was created in AsyncBeginReceive
@@ -419,7 +433,7 @@ namespace OpenMetaverse
                     // since this should be rare and  won't cause a runtime problem.
                     if (m_currentReceiveTimeSamples >= s_receiveTimeSamples)
                     {
-                        AverageReceiveTicksForLastSamplePeriod 
+                        AverageReceiveTicksForLastSamplePeriod
                             = (float)m_receiveTicksInCurrentSamplePeriod / s_receiveTimeSamples;
 
                         m_receiveTicksInCurrentSamplePeriod = 0;
@@ -431,16 +445,16 @@ namespace OpenMetaverse
                         m_currentReceiveTimeSamples++;
                     }
                 }
-                catch (SocketException se) 
-                { 
+                catch (SocketException se)
+                {
                     m_log.Error(
                         string.Format(
-                            "[UDPBASE]: Error processing UDP end receive {0}, socket error code {1}.  Exception  ", 
-                            UdpReceives, se.ErrorCode), 
+                            "[UDPBASE]: Error processing UDP end receive {0}, socket error code {1}.  Exception  ",
+                            UdpReceives, se.ErrorCode),
                         se);
                 }
-                catch (ObjectDisposedException e) 
-                { 
+                catch (ObjectDisposedException e)
+                {
                     m_log.Error(
                         string.Format("[UDPBASE]: Error processing UDP end receive {0}.  Exception  ", UdpReceives), e);
                 }
@@ -454,10 +468,7 @@ namespace OpenMetaverse
 //                    if (UsePools)
 //                        Pool.ReturnObject(buffer);
 
-                    // Synchronous mode waits until the packet callback completes
-                    // before starting the receive to fetch another packet
-                    if (!m_asyncPacketHandling)
-                        AsyncBeginReceive();
+                    AsyncBeginReceive();
                 }
             }
         }
@@ -471,7 +482,7 @@ namespace OpenMetaverse
                 // packets when testing throttles & retransmission code
                 // if (DropOutgoingPacket())
                 //     return;
-            
+
                 try
                 {
                     m_udpSocket.BeginSendTo(
@@ -485,7 +496,7 @@ namespace OpenMetaverse
                 }
                 catch (SocketException) { }
                 catch (ObjectDisposedException) { }
-//            }
+ //           }
         }
 
         void AsyncEndSend(IAsyncResult result)
@@ -500,5 +511,25 @@ namespace OpenMetaverse
             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) { }
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
index 5a2bcee..f585bea 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
@@ -62,7 +62,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// </summary>
         public int PacketsPooled
         {
-            get 
+            get
             {
                 lock (pool)
                     return pool.Count;
@@ -74,9 +74,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// </summary>
         public int BlocksPooled
         {
-            get 
+            get
             {
-                lock (DataBlocks) 
+                lock (DataBlocks)
                     return DataBlocks.Count;
             }
         }
@@ -248,7 +248,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             }
                         }
                         break;
-                    
+
                     // Other packets wont pool
                     default:
                         return;
@@ -276,7 +276,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 {
                     DataBlocks[typeof(T)] = new Stack<Object>();
                 }
-                
+
                 return new T();
             }
         }
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs b/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs
index bf505b4..4a8f16d 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs
@@ -3,7 +3,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Mono.Addins;
 
-// General Information about an assembly is controlled through the following 
+// 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")]
@@ -15,8 +15,8 @@ using Mono.Addins;
 [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 
+// 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)]
 
@@ -26,11 +26,11 @@ using Mono.Addins;
 // Version information for an assembly consists of the following four values:
 //
 //      Major Version
-//      Minor Version 
+//      Minor Version
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.8.3.*")]
+[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
index a935dd2..eb262d2 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
@@ -70,7 +70,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             m_scene = new SceneHelpers().SetupScene();
             StatsManager.SimExtraStats = new SimExtraStatsCollector();
         }
-        
+
 //        /// <summary>
 //        /// Build an object name packet for test purposes
 //        /// </summary>
@@ -84,13 +84,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 //            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()
         {
@@ -156,7 +157,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             config.Set("AckTimeout", -1);
             TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(m_scene, ics);
 
-            ScenePresence sp 
+            ScenePresence sp
                 = ClientStackHelpers.AddChildClient(
                     m_scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
 
@@ -165,7 +166,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             ScenePresence spAfterAckTimeout = m_scene.GetScenePresence(sp.UUID);
             Assert.That(spAfterAckTimeout, Is.Null);
         }
-
+*/
 //        /// <summary>
 //        /// Test removing a client from the stack
 //        /// </summary>
@@ -175,21 +176,21 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 //            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>
@@ -200,8 +201,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 //
 //            uint myCircuitCode = 123458;
 //            EndPoint testEp = new IPEndPoint(IPAddress.Loopback, 1001);
-//            MockScene scene = new MockScene(); 
-//            
+//            MockScene scene = new MockScene();
+//
 //            TestLLUDPServer testLLUDPServer;
 //            TestLLPacketServer testLLPacketServer;
 //            AgentCircuitManager acm;
@@ -213,24 +214,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 //            // Send two garbled 'packets' in succession
 //            testLLUDPServer.LoadReceive(data, testEp);
 //            testLLUDPServer.LoadReceive(data, testEp);
-//            testLLUDPServer.ReceiveData(null); 
-//            
+//            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 
+//        /// Test that the stack continues to work even if some client has caused a
 //        /// SocketException on Socket.BeginReceive()
 //        /// </summary>
 //        [Test]
@@ -239,32 +240,32 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 //            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/PacketHandlerTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
index 92f1fc3..1731aa9 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
@@ -59,7 +59,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 //            agent.InventoryFolder = UUID.Zero;
 //            agent.startpos = Vector3.Zero;
 //            agent.CapsPath = "http://wibble.com";
-//            
+//
 //            TestLLUDPServer testLLUDPServer;
 //            TestLLPacketServer testLLPacketServer;
 //            AgentCircuitManager acm;
@@ -67,7 +67,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 //            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
 //
 //            TestClient testClient = new TestClient(agent, scene);
-//            
+//
 //            LLPacketHandler packetHandler
 //                = new LLPacketHandler(testClient, testLLPacketServer, new ClientStackUserSettings());
 //
@@ -87,14 +87,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 //        /// <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, 
+//            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);
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs
index 3c82a78..873b1e5 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/ThrottleTests.cs
@@ -35,6 +35,7 @@ using OpenSim.Tests.Common;
 
 namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 {
+    /*
     [TestFixture]
     public class ThrottleTests : OpenSimTestCase
     {
@@ -57,16 +58,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
         [Test]
         public void TestSetRequestDripRate()
         {
+
             TestHelpers.InMethod();
 
-            TokenBucket tb = new TokenBucket("tb", null, 5000, 0);
+            TokenBucket tb = new TokenBucket(null, 5000f,10000f);
             AssertRates(tb, 5000, 0, 5000, 0);
 
-            tb.RequestedDripRate = 4000;
+            tb.RequestedDripRate = 4000f;
             AssertRates(tb, 4000, 0, 4000, 0);
 
             tb.RequestedDripRate = 6000;
             AssertRates(tb, 6000, 0, 6000, 0);
+
         }
 
         [Test]
@@ -74,7 +77,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
         {
             TestHelpers.InMethod();
 
-            TokenBucket tb = new TokenBucket("tb", null, 5000, 10000);
+            TokenBucket tb = new TokenBucket(null, 5000,15000);
             AssertRates(tb, 5000, 0, 5000, 10000);
 
             tb.RequestedDripRate = 4000;
@@ -92,9 +95,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
         {
             TestHelpers.InMethod();
 
-            TokenBucket tbParent = new TokenBucket("tbParent", null, 0, 0);
-            TokenBucket tbChild1 = new TokenBucket("tbChild1", tbParent, 3000, 0);
-            TokenBucket tbChild2 = new TokenBucket("tbChild2", tbParent, 5000, 0);
+            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);
@@ -113,6 +116,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             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(
@@ -133,7 +137,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             Scene scene = new SceneHelpers().SetupScene();
             TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene);
 
-            ScenePresence sp 
+            ScenePresence sp
                 = ClientStackHelpers.AddChildClient(
                     scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
 
@@ -141,7 +145,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 
             udpServer.Throttle.DebugLevel = 1;
             udpClient.ThrottleDebugLevel = 1;
-            
+
             int resendBytes = 1000;
             int landBytes = 2000;
             int windBytes = 3000;
@@ -157,8 +161,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             int totalBytes = LLUDPServer.MTU + landBytes + windBytes + cloudBytes + taskBytes + textureBytes + assetBytes;
 
             AssertThrottles(
-                udpClient, 
-                LLUDPServer.MTU, landBytes, windBytes, cloudBytes, taskBytes, 
+                udpClient,
+                LLUDPServer.MTU, landBytes, windBytes, cloudBytes, taskBytes,
                 textureBytes, assetBytes, totalBytes, 0, 0);
         }
 
@@ -177,7 +181,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 
             TestLLUDPServer udpServer = ClientStackHelpers.AddUdpServer(scene, ics);
 
-            ScenePresence sp 
+            ScenePresence sp
                 = ClientStackHelpers.AddChildClient(
                     scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
 
@@ -203,7 +207,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             double commitRatio = 32000.0 / totalBytes;
 
             AssertThrottles(
-                udpClient, 
+                udpClient,
                 LLUDPServer.MTU, landBytes * commitRatio, windBytes * commitRatio, cloudBytes * commitRatio, taskBytes * commitRatio,
                 textureBytes * commitRatio, assetBytes * commitRatio, udpClient.FlowThrottle.AdjustedDripRate, totalBytes, 0);
 
@@ -213,7 +217,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             commitRatio = (32000.0 + 20.0 * LLUDPServer.MTU) / totalBytes;
 
             AssertThrottles(
-                udpClient, 
+                udpClient,
                 LLUDPServer.MTU, landBytes * commitRatio, windBytes * commitRatio, cloudBytes * commitRatio, taskBytes * commitRatio,
                 textureBytes * commitRatio, assetBytes * commitRatio, udpClient.FlowThrottle.AdjustedDripRate, totalBytes, 0);
 
@@ -223,7 +227,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             commitRatio = (32000.0 + (20.0 * LLUDPServer.MTU)/Math.Pow(2,1)) / totalBytes;
 
             AssertThrottles(
-                udpClient, 
+                udpClient,
                 LLUDPServer.MTU, landBytes * commitRatio, windBytes * commitRatio, cloudBytes * commitRatio, taskBytes * commitRatio,
                 textureBytes * commitRatio, assetBytes * commitRatio, udpClient.FlowThrottle.AdjustedDripRate, totalBytes, 0);
         }
@@ -244,14 +248,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             int taskBytes = 14000;
             int textureBytes = 16000;
             int assetBytes = 18000;
-            int totalBytes 
+            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 
+            ScenePresence sp1
                 = ClientStackHelpers.AddChildClient(
                     scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
 
@@ -261,8 +265,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
                 udpClient1, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
 
             AssertThrottles(
-                udpClient1, 
-                resendBytes / 2, landBytes / 2, windBytes / 2, cloudBytes / 2, taskBytes / 2, 
+                udpClient1,
+                resendBytes / 2, landBytes / 2, windBytes / 2, cloudBytes / 2, taskBytes / 2,
                 textureBytes / 2, assetBytes / 2, totalBytes, 0, 0);
 
             // Test: Now add another client
@@ -277,13 +281,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
                 udpClient2, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
 
             AssertThrottles(
-                udpClient1, 
-                resendBytes / 4, landBytes / 4, windBytes / 4, cloudBytes / 4, taskBytes / 4, 
+                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, 
+                udpClient2,
+                resendBytes / 4, landBytes / 4, windBytes / 4, cloudBytes / 4, taskBytes / 4,
                 textureBytes / 4, assetBytes / 4, totalBytes / 2, 0, 0);
         }
 
@@ -303,14 +307,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             int taskBytes = 12000;
             int textureBytes = 14000;
             int assetBytes = 16000;
-            int totalBytes 
+            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 
+            ScenePresence sp
                 = ClientStackHelpers.AddChildClient(
                     scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
 
@@ -321,8 +325,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
                 udpClient, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
 
             AssertThrottles(
-                udpClient, 
-                resendBytes / 2, landBytes / 2, windBytes / 2, cloudBytes / 2, taskBytes / 2, 
+                udpClient,
+                resendBytes / 2, landBytes / 2, windBytes / 2, cloudBytes / 2, taskBytes / 2,
                 textureBytes / 2, assetBytes / 2, totalBytes, 0, totalBytes);
         }
 
@@ -348,7 +352,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             udpServer.ThrottleRates.Total = (int)(totalBytes * 1.1);
             udpServer.Throttle.RequestedDripRate = (int)(totalBytes * 1.5);
 
-            ScenePresence sp1 
+            ScenePresence sp1
                 = ClientStackHelpers.AddChildClient(
                     scene, udpServer, TestHelpers.ParseTail(0x1), TestHelpers.ParseTail(0x2), 123456);
 
@@ -359,8 +363,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
                 udpClient1, resendBytes, landBytes, windBytes, cloudBytes, taskBytes, textureBytes, assetBytes);
 
             AssertThrottles(
-                udpClient1, 
-                resendBytes, landBytes, windBytes, cloudBytes, taskBytes, 
+                udpClient1,
+                resendBytes, landBytes, windBytes, cloudBytes, taskBytes,
                 textureBytes, assetBytes, totalBytes, 0, totalBytes * 1.1);
 
             // Now add another client
@@ -375,25 +379,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
                 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, 
+                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, 
+                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, 
+            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}", 
+//                                "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");
@@ -424,4 +428,5 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
             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
index 7a2756b..f8ec97a 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/ThrottleRates.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/ThrottleRates.cs
@@ -58,17 +58,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         /// <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>
@@ -88,13 +91,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 Texture = throttleConfig.GetInt("texture_default", 18500);
                 Asset = throttleConfig.GetInt("asset_default", 10500);
 
-                Total = throttleConfig.GetInt("client_throttle_max_bps", 0);
+                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
 
-                AdaptiveThrottlesEnabled = throttleConfig.GetBoolean("enable_adaptive_throttles", false);
+                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);
 
-                CannibalizeTextureRate = (double)throttleConfig.GetFloat("CannibalizeTextureRate", 0.0f);
-                CannibalizeTextureRate = Util.Clamp<double>(CannibalizeTextureRate,0.0, 0.9);
+                // 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) { }
         }
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs b/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
index 4616203..1daf091 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
@@ -43,150 +43,143 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        public string Identifier { get; private set; }
+        private static Int32 m_counter = 0;
 
-        public int DebugLevel { get; set; }
-        
-        /// <summary>
-        /// Number of ticks (ms) per quantum, drip rate and max burst
-        /// are defined over this interval.
-        /// </summary>
-        protected const Int32 m_ticksPerQuantum = 1000;
+//        private Int32 m_identifier;
+
+        protected const float m_timeScale = 1e-3f;
 
         /// <summary>
-        /// This is the number of quantums worth of packets that can
-        /// be accommodated during a burst
+        /// 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 Double m_quantumsPerBurst = 1.5;
-                
+        protected const float m_quantumsPerBurst = 5;
+
         /// <summary>
         /// </summary>
-        protected const Int32 m_minimumDripRate = LLUDPServer.MTU;
-        
-        /// <summary>Time of the last drip, in system ticks</summary>
-        protected Int32 m_lastDrip;
+        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 Int64 m_tokenCount;
+        protected float m_tokenCount;
 
         /// <summary>
         /// Map of children buckets and their requested maximum burst rate
         /// </summary>
-        protected Dictionary<TokenBucket,Int64> m_children = new Dictionary<TokenBucket,Int64>();
+
+        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>
-        public TokenBucket Parent { get; protected set; }
-
+        protected TokenBucket m_parent;
+        public TokenBucket Parent
+        {
+            get { return m_parent; }
+            set { m_parent = value; }
+        }
         /// <summary>
-        /// Maximum burst rate in bytes per second. This is the maximum number
-        /// of tokens that can accumulate in the bucket at any one time. This 
+        /// 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 Int64 m_burstRate;
-        public Int64 RequestedBurstRate
+        protected float m_burst;
+
+        protected float m_maxDripRate = 0;
+        public virtual float MaxDripRate
         {
-            get { return m_burstRate; }
-            set { m_burstRate = (value < 0 ? 0 : value); }
+            get { return m_maxDripRate; }
+            set { m_maxDripRate = value; }
         }
 
-        public Int64 BurstRate
+        public float RequestedBurst
         {
-            get {
-                double rate = RequestedBurstRate * BurstRateModifier();
-                if (rate < m_minimumDripRate * m_quantumsPerBurst)
+            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;
-                
-                return (Int64) rate;
+
+                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 
+        /// 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)
-        /// FIXME: It is extremely confusing to be able to set a RequestedDripRate of 0 and then receive a positive
-        /// number on get if TotalDripRequest is set.  This also stops us being able to retrieve the fact that
-        /// RequestedDripRate is set to 0.  Really, this should always return m_dripRate and then we can get
-        /// (m_dripRate == 0 ? TotalDripRequest : m_dripRate) on some other properties.
-        /// </remarks>
-        public virtual Int64 RequestedDripRate
-        {
-            get { return (m_dripRate == 0 ? TotalDripRequest : m_dripRate); }
-            set 
-            {
-                if (value <= 0)
-                    m_dripRate = 0;
-                else if (MaxDripRate > 0 && value > MaxDripRate)
-                    m_dripRate = MaxDripRate;
-                else
-                    m_dripRate = value;
+        /// the system tick interval (typically around 15-22ms)</remarks>
+        protected float m_dripRate;
 
-                m_burstRate = (Int64)((double)m_dripRate * m_quantumsPerBurst);
+        public float RequestedDripRate
+        {
+            get { return (m_dripRate == 0 ? m_totalDripRequest : m_dripRate); }
+            set {
+                m_dripRate = (value < 0 ? 0 : value);
+                m_totalDripRequest = m_dripRate;
 
-                if (Parent != null)
-                    Parent.RegisterRequest(this, m_dripRate);
+                if (m_parent != null)
+                    m_parent.RegisterRequest(this,m_dripRate);
             }
         }
 
-        /// <summary>
-        /// Gets the drip rate.
-        /// </summary>
-        /// <value>
-        /// DripRate can never be above max drip rate or below min drip rate.
-        /// If we are a child bucket then the drip rate return is modifed by the total load on the capacity of the
-        /// parent bucket.
-        /// </value>
-        public virtual Int64 DripRate
+       public float DripRate
         {
-            get 
-            {
-                double rate;
-
-                // FIXME: This doesn't properly work if we have a parent and children and a requested drip rate set
-                // on ourselves which is not equal to the child drip rates.
-                if (Parent == null)
-                {
-                    if (TotalDripRequest > 0)
-                        rate = Math.Min(RequestedDripRate, TotalDripRequest);
-                    else
-                        rate = RequestedDripRate;
-                }   
-                else
-                {
-                    rate = (double)RequestedDripRate * Parent.DripRateModifier();
-                }
+            get {
+                float rate = Math.Min(RequestedDripRate,TotalDripRequest);
+                if (m_parent == null)
+                    return rate;
 
+                rate *= m_parent.DripRateModifier();
                 if (rate < m_minimumDripRate)
                     rate = m_minimumDripRate;
-                else if (MaxDripRate > 0 && rate > MaxDripRate)
-                    rate = MaxDripRate;
 
-                return (Int64)rate;
+                return (float)rate;
             }
         }
-        protected Int64 m_dripRate;
-
-        // <summary>
-        // The maximum rate for flow control. Drip rate can never be greater than this.
-        // </summary>
-        public Int64 MaxDripRate { get; set; }
 
         /// <summary>
         /// The current total of the requested maximum burst rates of children buckets.
         /// </summary>
-        public Int64 TotalDripRequest { get; protected set; }
+        protected float m_totalDripRequest;
+        public float TotalDripRequest
+        {
+            get { return m_totalDripRequest; }
+            set { m_totalDripRequest = value; }
+        }
+
+#endregion Properties
+
+#region Constructor
+
 
         /// <summary>
         /// Default constructor
@@ -194,20 +187,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <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="requestedDripRate">
-        /// Requested rate that the bucket fills, in bytes per
-        /// second. If zero, the bucket always remains full.
-        /// </param>
-        public TokenBucket(string identifier, TokenBucket parent, Int64 requestedDripRate, Int64 maxDripRate) 
+        /// <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)
         {
-            Identifier = identifier;
+            m_counter++;
 
             Parent = parent;
-            RequestedDripRate = requestedDripRate;
-            MaxDripRate = maxDripRate;
-            m_lastDrip = Util.EnvironmentTickCount();
+            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
@@ -215,22 +210,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// hierarchy. However, if any of the parents is over-booked, then
         /// the modifier will be less than 1.
         /// </summary>
-        protected double DripRateModifier()
+        protected float DripRateModifier()
         {
-            Int64 driprate = DripRate;
-            double modifier = driprate >= TotalDripRequest ? 1.0 : (double)driprate / (double)TotalDripRequest;
-
-//            if (DebugLevel > 0)
-//                m_log.DebugFormat(
-//                    "[TOKEN BUCKET]: Returning drip modifier {0}/{1} = {2} from {3}", 
-//                    driprate, TotalDripRequest, modifier, Identifier);
-
-            return modifier;
+            float driprate = DripRate;
+            return driprate >= TotalDripRequest ? 1.0f : (driprate / TotalDripRequest);
         }
 
         /// <summary>
         /// </summary>
-        protected double BurstRateModifier()
+        protected float BurstModifier()
         {
             // for now... burst rate is always m_quantumsPerBurst (constant)
             // larger than drip rate so the ratio of burst requests is the
@@ -242,29 +230,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// Register drip rate requested by a child of this throttle. Pass the
         /// changes up the hierarchy.
         /// </summary>
-        public void RegisterRequest(TokenBucket child, Int64 request)
+        public void RegisterRequest(TokenBucket child, float request)
         {
             lock (m_children)
             {
                 m_children[child] = request;
 
-                TotalDripRequest = 0;
-                foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
-                    TotalDripRequest += cref.Value;
+                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)
-            {
-                Int64 effectiveDripRate;
-
-                if (RequestedDripRate > 0)
-                    effectiveDripRate = Math.Min(RequestedDripRate, TotalDripRequest);
-                else
-                    effectiveDripRate = TotalDripRequest;
 
-                Parent.RegisterRequest(this, effectiveDripRate);
-            }
+            // Pass the new values up to the parent
+            if (m_parent != null)
+                m_parent.RegisterRequest(this, Math.Min(RequestedDripRate, TotalDripRequest));
         }
 
         /// <summary>
@@ -277,23 +256,23 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 m_children.Remove(child);
 
-                TotalDripRequest = 0;
-                foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
-                    TotalDripRequest += cref.Value;
+                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(Int64 amount)
+        public bool RemoveTokens(int amount)
         {
             // Deposit tokens for this interval
             Drip();
@@ -310,24 +289,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return false;
         }
 
-        /// <summary>
-        /// Deposit tokens into the bucket from a child bucket that did
-        /// not use all of its available tokens
-        /// </summary>
-        protected void Deposit(Int64 count)
+        public bool CheckTokens(int amount)
         {
-            m_tokenCount += count;
+            return  (m_tokenCount - amount >= 0);
+        }
 
-            // Deposit the overflow in the parent bucket, this is how we share
-            // unused bandwidth
-            Int64 burstrate = BurstRate;
-            if (m_tokenCount > burstrate)
-                m_tokenCount = burstrate;
+        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 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>
@@ -337,128 +312,106 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // with no drip rate...
             if (DripRate == 0)
             {
-                m_log.WarnFormat("[TOKENBUCKET] something odd is happening and drip rate is 0 for {0}", Identifier);
+                m_log.WarnFormat("[TOKENBUCKET] something odd is happening and drip rate is 0 for {0}", m_counter);
                 return;
             }
-            
-            // Determine the interval over which we are adding tokens, never add
-            // more than a single quantum of tokens
-            Int32 deltaMS = Math.Min(Util.EnvironmentTickCountSubtract(m_lastDrip), m_ticksPerQuantum);
-            m_lastDrip = Util.EnvironmentTickCount();
-
-            // This can be 0 in the very unusual case that the timer wrapped
-            // It can be 0 if we try add tokens at a sub-tick rate
+
+            double now = Util.GetTimeStampMS();
+            double deltaMS = now - m_lastDrip;
+            m_lastDrip = now;
+
             if (deltaMS <= 0)
                 return;
 
-            Deposit(deltaMS * DripRate / m_ticksPerQuantum);
+            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);               
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         public bool AdaptiveEnabled { get; set; }
 
         /// <summary>
-        /// Target drip rate for this bucket.
+        /// The minimum rate for flow control. Minimum drip rate is one
+        /// packet per second.
         /// </summary>
-        /// <remarks>Usually set by the client.  If adaptive is enabled then throttles will increase until we reach this.</remarks>
-        public Int64 TargetDripRate 
-        { 
-            get { return m_targetDripRate; }
-            set 
+
+        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_targetDripRate = Math.Max(value, m_minimumFlow);
+                m_maxDripRate = (value == 0 ? m_totalDripRequest : Math.Max(value, m_minimumFlow));
             }
         }
-        protected Int64 m_targetDripRate;
+
+        private bool m_enabled = false;
 
         // <summary>
-        // Adjust drip rate in response to network conditions. 
+        // Adjust drip rate in response to network conditions.
         // </summary>
-        public virtual Int64 AdjustedDripRate
+        public float AdjustedDripRate
         {
             get { return m_dripRate; }
-            set 
+            set
             {
-                m_dripRate = OpenSim.Framework.Util.Clamp<Int64>(value, m_minimumFlow, TargetDripRate);
-                m_burstRate = (Int64)((double)m_dripRate * m_quantumsPerBurst);
+                m_dripRate = OpenSim.Framework.Util.Clamp<float>(value, m_minimumFlow, MaxDripRate);
 
-                if (Parent != null)
-                    Parent.RegisterRequest(this, m_dripRate);
+                if (m_parent != null)
+                    m_parent.RegisterRequest(this, m_dripRate);
             }
         }
-                
-        /// <summary>
-        /// The minimum rate for adaptive flow control. 
-        /// </summary>
-        protected Int64 m_minimumFlow = 32000;
 
-        /// <summary>
-        /// Constructor for the AdaptiveTokenBucket class
-        /// <param name="identifier">Unique identifier for the client</param>
-        /// <param name="parent">Parent bucket in the hierarchy</param>
-        /// <param name="requestedDripRate"></param>
-        /// <param name="maxDripRate">The ceiling rate for adaptation</param>
-        /// <param name="minDripRate">The floor rate for adaptation</param>
-        /// </summary>
-        public AdaptiveTokenBucket(string identifier, TokenBucket parent, Int64 requestedDripRate, Int64 maxDripRate, Int64 minDripRate, bool enabled) 
-            : base(identifier, parent, requestedDripRate, maxDripRate)
-        {
-            AdaptiveEnabled = enabled;
 
-            if (AdaptiveEnabled)
-            {
-//                m_log.DebugFormat("[TOKENBUCKET]: Adaptive throttle enabled");
-                m_minimumFlow = minDripRate;
-                TargetDripRate = m_minimumFlow;
-                AdjustedDripRate = m_minimumFlow;
-            }
-        }
-                
-        /// <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 packets)
+        // <summary>
+        //
+        // </summary>
+        public AdaptiveTokenBucket(TokenBucket parent, float maxDripRate, float maxBurst, bool enabled)
+            : base(parent, maxDripRate, maxBurst)
         {
-            if (AdaptiveEnabled)
-            {
-                if (DebugLevel > 0)
-                    m_log.WarnFormat(
-                        "[ADAPTIVEBUCKET] drop {0} by {1} expired packets for {2}", 
-                        AdjustedDripRate, packets, Identifier);
+            m_enabled = enabled;
 
-                // AdjustedDripRate = (Int64) (AdjustedDripRate / Math.Pow(2,packets));
+            m_maxDripRate = (maxDripRate == 0 ? m_totalDripRequest : Math.Max(maxDripRate, m_minimumFlow));
 
-                // Compute the fallback solely on the rate allocated beyond the minimum, this
-                // should smooth out the fallback to the minimum rate
-                AdjustedDripRate = m_minimumFlow + (Int64) ((AdjustedDripRate - m_minimumFlow) / Math.Pow(2, packets));
-            }
+            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 acked by the client adjust the drip rate up.
-        /// <param name="packets">Number of packets successfully acknowledged</param>
+        /// 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 AcknowledgePackets(Int32 packets)
+        public void ExpirePackets(Int32 count)
         {
-            if (AdaptiveEnabled)
-                AdjustedDripRate = AdjustedDripRate + packets * LLUDPServer.MTU;
+            // m_log.WarnFormat("[ADAPTIVEBUCKET] drop {0} by {1} expired packets",AdjustedDripRate,count);
+            if (m_enabled)
+                AdjustedDripRate = (Int64)(AdjustedDripRate / Math.Pow(2, count));
         }
 
-        /// <summary>
-        /// Adjust the minimum flow level for the adaptive throttle, this will drop adjusted
-        /// throttles back to the minimum levels
-        /// <param>minDripRate--the new minimum flow</param>
-        /// </summary>
-        public void ResetMinimumAdaptiveFlow(Int64 minDripRate)
+        // <summary>
+        //
+        // </summary>
+        public void AcknowledgePackets(Int32 count)
         {
-            m_minimumFlow = minDripRate;
-            TargetDripRate = m_minimumFlow;
-            AdjustedDripRate = m_minimumFlow;
+            if (m_enabled)
+                AdjustedDripRate = AdjustedDripRate + count;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs b/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs
index b546a99..76f4c6f 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs
@@ -74,6 +74,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <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>
@@ -85,7 +94,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public void Add(OutgoingPacket packet)
         {
             m_pendingAdds.Enqueue(packet);
-            Interlocked.Add(ref packet.Client.UnackedBytes, packet.Buffer.DataLength);            
+            Interlocked.Add(ref packet.Client.UnackedBytes, packet.Buffer.DataLength);
         }
 
         /// <summary>
@@ -107,7 +116,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <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 
+        /// 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
@@ -146,7 +155,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 foreach (OutgoingPacket packet in m_packets.Values)
                 {
-                    // TickCount of zero means a packet is in the resend queue 
+                    // 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;
@@ -163,7 +172,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         // 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);
                     }
                 }
@@ -182,7 +191,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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))
@@ -219,7 +228,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 else
                 {
                     // m_log.WarnFormat("[UNACKED PACKET COLLECTION]: Could not find packet with sequence number {0} to ack",
-                    //                  pendingAcknowledgement.SequenceNumber);                    
+                    //                  pendingAcknowledgement.SequenceNumber);
                 }
             }
 
diff --git a/OpenSim/Region/ClientStack/Properties/AssemblyInfo.cs b/OpenSim/Region/ClientStack/Properties/AssemblyInfo.cs
index 0b6ee2f..e859653 100644
--- a/OpenSim/Region/ClientStack/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/ClientStack/Properties/AssemblyInfo.cs
@@ -2,7 +2,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-// General Information about an assembly is controlled through the following 
+// 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")]
@@ -14,8 +14,8 @@ using System.Runtime.InteropServices;
 [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 
+// 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)]
 
@@ -25,7 +25,7 @@ using System.Runtime.InteropServices;
 // Version information for an assembly consists of the following four values:
 //
 //      Major Version
-//      Minor Version 
+//      Minor Version
 //      Build Number
 //      Revision
 //
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetDisplayNamesModule.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/MuteList/RemoteMuteListServiceConnector.cs
index 6617bbc..a5dec64 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/GetDisplayNamesModule.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/MuteList/RemoteMuteListServiceConnector.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -24,121 +24,120 @@
  * (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.Collections.Generic;
 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.Server.Base;
 using OpenSim.Services.Interfaces;
-using Caps = OpenSim.Framework.Capabilities.Caps;
-using OpenSim.Capabilities.Handlers;
+using OpenSim.Services.Connectors;
 
-namespace OpenSim.Region.ClientStack.Linden
-{
+using OpenMetaverse;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
 
-    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "GetDisplayNamesModule")]
-    public class GetDisplayNamesModule : INonSharedRegionModule
+namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.MuteList
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "RemoteMuteListServicesConnector")]
+    public class RemoteMuteListServicesConnector : ISharedRegionModule, IMuteListService
     {
-        private static readonly ILog m_log =
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
-        private Scene m_scene;
-        private IUserManagement m_UserManager;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        #region ISharedRegionModule
 
         private bool m_Enabled = false;
 
-        private string m_URL;
+        private IMuteListService m_remoteConnector;
 
-        #region ISharedRegionModule Members
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public string Name
+        {
+            get { return "RemoteMuteListServicesConnector"; }
+        }
 
         public void Initialise(IConfigSource source)
         {
-            IConfig config = source.Configs["ClientStack.LindenCaps"];
-            if (config == null)
+           // only active for core mute lists module
+            IConfig moduleConfig = source.Configs["Messaging"];
+            if (moduleConfig == null)
                 return;
 
-            m_URL = config.GetString("Cap_GetDisplayNames", string.Empty);
-            if (m_URL != string.Empty)
-                m_Enabled = true;
+            if (moduleConfig.GetString("MuteListModule", "None") != "MuteListModuleTst")
+                return;
+            
+            moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("MuteListService", "");
+                if (name == Name)
+                {
+                    m_remoteConnector = new MuteListServicesConnector(source);
+                    m_Enabled = true;
+                }
+            }
         }
 
-        public void AddRegion(Scene s)
+        public void PostInitialise()
         {
-            if (!m_Enabled)
-                return;
+        }
 
-            m_scene = s;
+        public void Close()
+        {
         }
 
-        public void RemoveRegion(Scene s)
+        public void AddRegion(Scene scene)
         {
             if (!m_Enabled)
                 return;
 
-            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
-            m_scene = null;
+            scene.RegisterModuleInterface<IMuteListService>(this);
+            m_log.InfoFormat("[MUTELIST CONNECTOR]: Enabled for region {0}", scene.RegionInfo.RegionName);
         }
 
-        public void RegionLoaded(Scene s)
+        public void RemoveRegion(Scene scene)
         {
             if (!m_Enabled)
                 return;
-
-            m_UserManager = m_scene.RequestModuleInterface<IUserManagement>();
-            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
         }
 
-        public void PostInitialise()
+        public void RegionLoaded(Scene scene)
         {
+            if (!m_Enabled)
+                return;
         }
 
-        public void Close() { }
-
-        public string Name { get { return "GetDisplayNamesModule"; } }
+        #endregion
 
-        public Type ReplaceableInterface
+        #region IMuteListService
+        public Byte[] MuteListRequest(UUID agentID, uint crc)
         {
-            get { return null; }
+            if (!m_Enabled)
+                return null;
+            return m_remoteConnector.MuteListRequest(agentID, crc);
         }
 
-        #endregion
-
-        public void RegisterCaps(UUID agentID, Caps caps)
+        public bool UpdateMute(MuteData mute)
         {
-            UUID capID = UUID.Random();
+            if (!m_Enabled)
+                return false;
+            return m_remoteConnector.UpdateMute(mute);
+        }
 
-            if (m_URL == "localhost")
-            {
-                m_log.DebugFormat("[GET_DISPLAY_NAMES]: /CAPS/agents/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
-                caps.RegisterHandler(
-                    "GetDisplayNames",
-                    new GetDisplayNamesHandler("/CAPS/agents" + capID + "/", m_UserManager, "GetDisplayNames", agentID.ToString()));
-            }
-            else
-            {
-//                m_log.DebugFormat("[GETTEXTURE]: {0} in region {1}", m_URL, m_scene.RegionInfo.RegionName);
-                IExternalCapsModule handler = m_scene.RequestModuleInterface<IExternalCapsModule>();
-                if (handler != null)
-                    handler.RegisterExternalUserCapsHandler(agentID,caps,"GetDisplayNames", m_URL);
-                else
-                    caps.RegisterHandler("GetDisplayNames", m_URL);
-            }
+        public bool RemoveMute(UUID agentID, UUID muteID, string muteName)
+        {
+            if (!m_Enabled)
+                return false;
+            return m_remoteConnector.RemoveMute(agentID, muteID, muteName);
         }
 
+        #endregion IMuteListService
+
     }
 }