36 files changed, 7708 insertions, 2650 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
new file mode 100644
index 0000000..2347cf2
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
@@ -0,0 +1,1021 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Text;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nini.Config;
+using log4net;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Scenes.Serialization;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Services.Interfaces;
+
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OSDArray = OpenMetaverse.StructuredData.OSDArray;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+
+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);
+
+    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 NewAsset(AssetBase asset);
+
+    public delegate UUID ItemUpdatedCallback(UUID userID, UUID itemID, byte[] data);
+
+    public delegate ArrayList TaskScriptUpdatedCallback(UUID userID, UUID itemID, UUID primID,
+                                                   bool isScriptRunning, byte[] data);
+
+    public delegate InventoryCollection FetchInventoryDescendentsCAPS(UUID agentID, UUID folderID, UUID ownerID,
+                                                                          bool fetchFolders, bool fetchItems, int sortOrder, out int version);
+
+    /// <summary>
+    /// XXX Probably not a particularly nice way of allow us to get the scene presence from the scene (chiefly so that
+    /// we can popup a message on the user's client if the inventory service has permanently failed).  But I didn't want
+    /// to just pass the whole Scene into CAPS.
+    /// </summary>
+    public delegate IClientAPI GetClientDelegate(UUID agentID);
+
+    public class BunchOfCaps
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_Scene;
+        private Caps m_HostCapsObj;
+
+        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_remoteParcelRequestPath = "0009/";// This is in the LandManagementModule.
+
+
+        // These are callbacks which will be setup by the scene so that we can update scene data when we
+        // receive capability calls
+        public NewInventoryItem AddNewInventoryItem = null;
+        public NewAsset AddNewAsset = null;
+        public ItemUpdatedCallback ItemUpdatedCall = null;
+        public TaskScriptUpdatedCallback TaskScriptUpdatedCall = null;
+        public FetchInventoryDescendentsCAPS CAPSFetchInventoryDescendents = null;
+        public GetClientDelegate GetClient = null;
+
+        private bool m_persistBakedTextures = false;
+        private IAssetService m_assetService;
+        private bool m_dumpAssetsToFile = false;
+        private string m_regionName;
+
+        public BunchOfCaps(Scene scene, Caps caps)
+        {
+            m_Scene = scene;
+            m_HostCapsObj = caps;
+            IConfigSource config = m_Scene.Config;
+            if (config != null)
+            {
+                IConfig sconfig = config.Configs["Startup"];
+                if (sconfig != null)
+                    m_persistBakedTextures = sconfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
+            }
+
+            m_assetService = m_Scene.AssetService;
+            m_regionName = m_Scene.RegionInfo.RegionName;
+
+            RegisterHandlers();
+
+            AddNewInventoryItem = m_Scene.AddUploadedInventoryItem;
+            ItemUpdatedCall = m_Scene.CapsUpdateInventoryItemAsset;
+            TaskScriptUpdatedCall = m_Scene.CapsUpdateTaskInventoryScriptAsset;
+            GetClient = m_Scene.SceneGraph.GetControllingClient;
+        }
+
+        /// <summary>
+        /// Register a bunch of CAPS http service handlers
+        /// </summary>
+        public void RegisterHandlers()
+        {
+            string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+
+            RegisterRegionServiceHandlers(capsBase);
+            RegisterInventoryServiceHandlers(capsBase);
+        }
+
+        public void RegisterRegionServiceHandlers(string capsBase)
+        {
+            try
+            {
+                // the root of all evil
+                m_HostCapsObj.RegisterHandler("SEED", new RestStreamHandler("POST", capsBase + m_requestPath, SeedCapRequest));
+                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);
+                m_HostCapsObj.RegisterHandler("UpdateScriptTaskInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateScriptTask", req);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+        }
+
+        public void RegisterInventoryServiceHandlers(string capsBase)
+        {
+            try
+            {
+                // I don't think this one works...
+                m_HostCapsObj.RegisterHandler("NewFileAgentInventory", new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDAssetUploadResponse>("POST",
+                                                                                           capsBase + m_newInventory,
+                                                                                           NewAgentInventoryRequest));
+                IRequestHandler req = new RestStreamHandler("POST", capsBase + m_notecardUpdatePath, NoteCardAgentInventory);
+                m_HostCapsObj.RegisterHandler("UpdateNotecardAgentInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateScriptAgentInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateScriptAgent", req);
+             
+                // 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);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Construct a client response detailing all the capabilities this server can provide.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="httpRequest">HTTP request header object</param>
+        /// <param name="httpResponse">HTTP response header object</param>
+        /// <returns></returns>
+        public string SeedCapRequest(string request, string path, string param,
+                                  IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+//            m_log.Debug("[CAPS]: Seed Caps Request in region: " + m_regionName);
+
+            if (!m_Scene.CheckClient(m_HostCapsObj.AgentID, httpRequest.RemoteIPEndPoint))
+            {
+                m_log.DebugFormat("[CAPS]: Unauthorized CAPS client");
+                return string.Empty;
+            }
+
+            Hashtable caps = m_HostCapsObj.CapsHandlers.GetCapsDetails(true);
+
+            // Add the external too
+            foreach (KeyValuePair<string, string> kvp in m_HostCapsObj.ExternalCapsHandlers)
+                caps[kvp.Key] = kvp.Value;
+
+            string result = LLSDHelpers.SerialiseLLSDReply(caps);
+
+            //m_log.DebugFormat("[CAPS] CapsRequest {0}", result);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Called by the script task update handler.  Provides a URL to which the client can upload a new asset.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="httpRequest">HTTP request header object</param>
+        /// <param name="httpResponse">HTTP response header object</param>
+        /// <returns></returns>
+        public string ScriptTaskInventory(string request, string path, string param,
+                                          IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            try
+            {
+                m_log.Debug("[CAPS]: ScriptTaskInventory Request in region: " + m_regionName);
+                //m_log.DebugFormat("[CAPS]: request: {0}, path: {1}, param: {2}", request, path, param);
+
+                Hashtable hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+                LLSDTaskScriptUpdate llsdUpdateRequest = new LLSDTaskScriptUpdate();
+                LLSDHelpers.DeserialiseOSDMap(hash, llsdUpdateRequest);
+
+                string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+                string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+
+                TaskInventoryScriptUpdater uploader =
+                    new TaskInventoryScriptUpdater(
+                        llsdUpdateRequest.item_id,
+                        llsdUpdateRequest.task_id,
+                        llsdUpdateRequest.is_script_running,
+                        capsBase + uploaderPath,
+                        m_HostCapsObj.HttpListener,
+                        m_dumpAssetsToFile);
+                uploader.OnUpLoad += TaskScriptUpdated;
+
+                m_HostCapsObj.HttpListener.AddStreamHandler(new BinaryStreamHandler("POST", capsBase + uploaderPath, uploader.uploaderCaps));
+
+                string protocol = "http://";
+
+                if (m_HostCapsObj.SSLCaps)
+                    protocol = "https://";
+
+                string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
+                                     uploaderPath;
+
+                LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+                uploadResponse.uploader = uploaderURL;
+                uploadResponse.state = "upload";
+
+                //                m_log.InfoFormat("[CAPS]: " +
+                //                                 "ScriptTaskInventory response: {0}",
+                //                                 LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
+
+                return LLSDHelpers.SerialiseLLSDReply(uploadResponse);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Called when new asset data for an agent inventory item update has been uploaded.
+        /// </summary>
+        /// <param name="itemID">Item to update</param>
+        /// <param name="primID">Prim containing item to update</param>
+        /// <param name="isScriptRunning">Signals whether the script to update is currently running</param>
+        /// <param name="data">New asset data</param>
+        public void TaskScriptUpdated(UUID itemID, UUID primID, bool isScriptRunning, byte[] data, ref ArrayList errors)
+        {
+            if (TaskScriptUpdatedCall != null)
+            {
+                ArrayList e = TaskScriptUpdatedCall(m_HostCapsObj.AgentID, itemID, primID, isScriptRunning, data);
+                foreach (Object item in e)
+                    errors.Add(item);
+            }
+        }
+
+        /// <summary>
+        /// Called when new asset data for an agent inventory item update has been uploaded.
+        /// </summary>
+        /// <param name="itemID">Item to update</param>
+        /// <param name="data">New asset data</param>
+        /// <returns></returns>
+        public UUID ItemUpdated(UUID itemID, byte[] data)
+        {
+            if (ItemUpdatedCall != null)
+            {
+                return ItemUpdatedCall(m_HostCapsObj.AgentID, itemID, data);
+            }
+
+            return UUID.Zero;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="llsdRequest"></param>
+        /// <returns></returns>
+        public LLSDAssetUploadResponse NewAgentInventoryRequest(LLSDAssetUploadRequest llsdRequest)
+        {
+            //m_log.Debug("[CAPS]: NewAgentInventoryRequest Request is: " + llsdRequest.ToString());
+            //m_log.Debug("asset upload request via CAPS" + llsdRequest.inventory_type + " , " + llsdRequest.asset_type);
+
+            if (llsdRequest.asset_type == "texture" ||
+                llsdRequest.asset_type == "animation" ||
+                llsdRequest.asset_type == "sound")
+            {
+                IClientAPI client = null;
+                IScene scene = null;
+                if (GetClient != null)
+                {
+                    client = GetClient(m_HostCapsObj.AgentID);
+                    scene = client.Scene;
+
+                    IMoneyModule mm = scene.RequestModuleInterface<IMoneyModule>();
+
+                    if (mm != null)
+                    {
+                        if (!mm.UploadCovered(client, mm.UploadCharge))
+                        {
+                            if (client != null)
+                                client.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
+
+                            LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
+                            errorResponse.uploader = "";
+                            errorResponse.state = "error";
+                            return errorResponse;
+                        }
+                    }
+                }
+            }
+
+            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");
+
+            AssetUploader uploader =
+                new AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
+                                  llsdRequest.asset_type, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
+            m_HostCapsObj.HttpListener.AddStreamHandler(
+                new BinaryStreamHandler("POST", capsBase + uploaderPath, uploader.uploaderCaps));
+
+            string protocol = "http://";
+
+            if (m_HostCapsObj.SSLCaps)
+                protocol = "https://";
+
+            string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
+                                 uploaderPath;
+
+            LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+            uploadResponse.uploader = uploaderURL;
+            uploadResponse.state = "upload";
+            uploader.OnUpLoad += UploadCompleteHandler;
+            return uploadResponse;
+        }
+
+        /// <summary>
+        /// Convert raw uploaded data into the appropriate asset and item.
+        /// </summary>
+        /// <param name="assetID"></param>
+        /// <param name="inventoryItem"></param>
+        /// <param name="data"></param>
+        public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
+                                          UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
+                                          string assetType)
+        {
+            m_log.DebugFormat(
+                "Uploaded asset {0} for inventory item {1}, inv type {2}, asset type {3}",
+                assetID, inventoryItem, inventoryType, assetType);
+
+            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 == "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;
+
+                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);
+                }
+
+                for (int i = 0; i < mesh_list.Count; i++)
+                {
+                    PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+
+                    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"];
+                    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();
+
+                        int textureNum = faceMap["image"].AsInteger();
+                        float imagerot = faceMap["imagerot"].AsInteger();
+                        float offsets = (float)faceMap["offsets"].AsReal();
+                        float offsett = (float)faceMap["offsett"].AsReal();
+                        float scales = (float)faceMap["scales"].AsReal();
+                        float scalet = (float)faceMap["scalet"].AsReal();
+
+                        if(imagerot != 0)
+                            f.Rotation = imagerot;
+
+                        if(offsets != 0)
+                            f.OffsetU = offsets;
+
+                        if (offsett != 0)
+                            f.OffsetV = offsett;
+
+                        if (scales != 0)
+                            f.RepeatU = scales;
+
+                        if (scalet != 0)
+                            f.RepeatV = scalet;
+
+                        if (textures.Count > textureNum)
+                            f.TextureID = textures[textureNum];
+                        else
+                            f.TextureID = Primitive.TextureEntry.WHITE_TEXTURE;
+
+                        textureEntry.FaceTextures[face] = f;
+                    }
+
+                    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 = "";
+
+//                    prim.BaseMask = (uint)base_mask;
+//                    prim.EveryoneMask = (uint)everyone_mask;
+//                    prim.GroupMask = (uint)group_mask;
+//                    prim.NextOwnerMask = (uint)next_owner_mask;
+//                    prim.OwnerMask = (uint)owner_mask;
+
+                    if (grp == null)
+                        grp = new SceneObjectGroup(prim);
+                    else
+                        grp.AddPart(prim);
+                }
+
+                // Fix first link number
+                if (grp.Parts.Length > 1)
+                    grp.RootPart.LinkNum++;
+
+                Vector3 rootPos = positions[0];
+                grp.AbsolutePosition = rootPos;
+                for (int i = 0; i < positions.Count; i++)
+                {
+                    Vector3 offset = positions[i] - rootPos;
+                    grp.Parts[i].OffsetPosition = offset;
+                }
+
+                for (int i = 0; i < rotations.Count; i++)
+                {
+                    if (i != 0)
+                        grp.Parts[i].RotationOffset = rotations[i];
+                }
+
+                grp.UpdateGroupRotationR(rotations[0]);
+                data = ASCIIEncoding.ASCII.GetBytes(SceneObjectSerializer.ToOriginalXmlFormat(grp));
+            }
+
+            AssetBase asset;
+            asset = new AssetBase(assetID, assetName, assType, m_HostCapsObj.AgentID.ToString());
+            asset.Data = data;
+            if (AddNewAsset != null)
+                AddNewAsset(asset);
+            else if (m_assetService != null)
+                m_assetService.Store(asset);
+
+            InventoryItemBase item = new InventoryItemBase();
+            item.Owner = m_HostCapsObj.AgentID;
+            item.CreatorId = m_HostCapsObj.AgentID.ToString();
+            item.CreatorData = String.Empty;
+            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.All;
+            item.BasePermissions = (uint)PermissionMask.All;
+            item.EveryOnePermissions = 0;
+            item.NextPermissions = (uint)PermissionMask.All;
+            item.CreationDate = Util.UnixTimeSinceEpoch();
+
+            if (AddNewInventoryItem != null)
+            {
+                AddNewInventoryItem(m_HostCapsObj.AgentID, item);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="mapReq"></param>
+        /// <returns></returns>
+        public LLSDMapLayerResponse GetMapLayer(LLSDMapRequest mapReq)
+        {
+            m_log.Debug("[CAPS]: MapLayer Request in region: " + m_regionName);
+            LLSDMapLayerResponse mapResponse = new LLSDMapLayerResponse();
+            mapResponse.LayerData.Array.Add(GetOSDMapLayerResponse());
+            return mapResponse;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected static OSDMapLayer GetOSDMapLayerResponse()
+        {
+            OSDMapLayer mapLayer = new OSDMapLayer();
+            mapLayer.Right = 5000;
+            mapLayer.Top = 5000;
+            mapLayer.ImageID = new UUID("00000000-0000-1111-9999-000000000006");
+
+            return mapLayer;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string RequestTexture(string request, string path, string param)
+        {
+            m_log.Debug("texture request " + request);
+            // Needs implementing (added to remove compiler warning)
+            return String.Empty;
+        }
+
+
+        /// <summary>
+        /// Called by the notecard update handler.  Provides a URL to which the client can upload a new asset.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string NoteCardAgentInventory(string request, string path, string param,
+                                             IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            //m_log.Debug("[CAPS]: NoteCardAgentInventory Request in region: " + m_regionName + "\n" + request);
+            //m_log.Debug("[CAPS]: NoteCardAgentInventory Request is: " + request);
+
+            //OpenMetaverse.StructuredData.OSDMap hash = (OpenMetaverse.StructuredData.OSDMap)OpenMetaverse.StructuredData.LLSDParser.DeserializeBinary(Utils.StringToBytes(request));
+            Hashtable hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+            LLSDItemUpdate llsdRequest = new LLSDItemUpdate();
+            LLSDHelpers.DeserialiseOSDMap(hash, llsdRequest);
+
+            string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+            string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+
+            ItemUpdater uploader =
+                new ItemUpdater(llsdRequest.item_id, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
+            uploader.OnUpLoad += ItemUpdated;
+
+            m_HostCapsObj.HttpListener.AddStreamHandler(
+                new BinaryStreamHandler("POST", capsBase + uploaderPath, uploader.uploaderCaps));
+
+            string protocol = "http://";
+
+            if (m_HostCapsObj.SSLCaps)
+                protocol = "https://";
+
+            string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
+                                 uploaderPath;
+
+            LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+            uploadResponse.uploader = uploaderURL;
+            uploadResponse.state = "upload";
+
+            //            m_log.InfoFormat("[CAPS]: " +
+            //                             "NoteCardAgentInventory response: {0}",
+            //                             LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
+
+            return LLSDHelpers.SerialiseLLSDReply(uploadResponse);
+        }
+    }
+
+    public class AssetUploader
+    {
+        public event UpLoadedAsset OnUpLoad;
+        private UpLoadedAsset handlerUpLoad = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID newAssetID;
+        private UUID inventoryItemID;
+        private UUID parentFolder;
+        private IHttpServer httpListener;
+        private bool m_dumpAssetsToFile;
+        private string m_assetName = String.Empty;
+        private string m_assetDes = String.Empty;
+
+        private string m_invType = String.Empty;
+        private string m_assetType = String.Empty;
+
+        public AssetUploader(string assetName, string description, UUID assetID, UUID inventoryItem,
+                                UUID parentFolderID, string invType, string assetType, string path,
+                                IHttpServer httpServer, bool dumpAssetsToFile)
+        {
+            m_assetName = assetName;
+            m_assetDes = description;
+            newAssetID = assetID;
+            inventoryItemID = inventoryItem;
+            uploaderPath = path;
+            httpListener = httpServer;
+            parentFolder = parentFolderID;
+            m_assetType = assetType;
+            m_invType = invType;
+            m_dumpAssetsToFile = dumpAssetsToFile;
+        }
+
+        /// <summary>
+        /// Handle raw asset upload data via the capability.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            UUID inv = inventoryItemID;
+            string res = String.Empty;
+            LLSDAssetUploadComplete uploadComplete = new LLSDAssetUploadComplete();
+            uploadComplete.new_asset = newAssetID.ToString();
+            uploadComplete.new_inventory_item = inv;
+            uploadComplete.state = "complete";
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+            // TODO: probably make this a better set of extensions here
+            string extension = ".jp2";
+            if (m_invType != "image")
+            {
+                extension = ".dat";
+            }
+
+            if (m_dumpAssetsToFile)
+            {
+                SaveAssetToFile(m_assetName + extension, data);
+            }
+            handlerUpLoad = OnUpLoad;
+            if (handlerUpLoad != null)
+            {
+                handlerUpLoad(m_assetName, m_assetDes, newAssetID, inv, parentFolder, data, m_invType, m_assetType);
+            }
+
+            return res;
+        }
+
+        ///Left this in and commented in case there are unforseen issues
+        //private void SaveAssetToFile(string filename, byte[] data)
+        //{
+        //    FileStream fs = File.Create(filename);
+        //    BinaryWriter bw = new BinaryWriter(fs);
+        //    bw.Write(data);
+        //    bw.Close();
+        //    fs.Close();
+        //}
+
+        private static void SaveAssetToFile(string filename, byte[] data)
+        {
+            string assetPath = "UserAssets";
+            if (!Directory.Exists(assetPath))
+            {
+                Directory.CreateDirectory(assetPath);
+            }
+            FileStream fs = File.Create(Path.Combine(assetPath, Util.safeFileName(filename)));
+            BinaryWriter bw = new BinaryWriter(fs);
+            bw.Write(data);
+            bw.Close();
+            fs.Close();
+        }
+    }
+
+    /// <summary>
+    /// This class is a callback invoked when a client sends asset data to
+    /// an agent inventory notecard update url
+    /// </summary>
+    public class ItemUpdater
+    {
+        public event UpdateItem OnUpLoad;
+
+        private UpdateItem handlerUpdateItem = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID inventoryItemID;
+        private IHttpServer httpListener;
+        private bool m_dumpAssetToFile;
+
+        public ItemUpdater(UUID inventoryItem, string path, IHttpServer httpServer, bool dumpAssetToFile)
+        {
+            m_dumpAssetToFile = dumpAssetToFile;
+
+            inventoryItemID = inventoryItem;
+            uploaderPath = path;
+            httpListener = httpServer;
+        }
+
+        /// <summary>
+        /// Handle raw uploaded asset data.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            UUID inv = inventoryItemID;
+            string res = String.Empty;
+            LLSDAssetUploadComplete uploadComplete = new LLSDAssetUploadComplete();
+            UUID assetID = UUID.Zero;
+            handlerUpdateItem = OnUpLoad;
+            if (handlerUpdateItem != null)
+            {
+                assetID = handlerUpdateItem(inv, data);
+            }
+
+            uploadComplete.new_asset = assetID.ToString();
+            uploadComplete.new_inventory_item = inv;
+            uploadComplete.state = "complete";
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+            if (m_dumpAssetToFile)
+            {
+                SaveAssetToFile("updateditem" + Util.RandomClass.Next(1, 1000) + ".dat", data);
+            }
+
+            return res;
+        }
+
+        ///Left this in and commented in case there are unforseen issues
+        //private void SaveAssetToFile(string filename, byte[] data)
+        //{
+        //    FileStream fs = File.Create(filename);
+        //    BinaryWriter bw = new BinaryWriter(fs);
+        //    bw.Write(data);
+        //    bw.Close();
+        //    fs.Close();
+        //}
+
+        private static void SaveAssetToFile(string filename, byte[] data)
+        {
+            string assetPath = "UserAssets";
+            if (!Directory.Exists(assetPath))
+            {
+                Directory.CreateDirectory(assetPath);
+            }
+            FileStream fs = File.Create(Path.Combine(assetPath, filename));
+            BinaryWriter bw = new BinaryWriter(fs);
+            bw.Write(data);
+            bw.Close();
+            fs.Close();
+        }
+    }
+
+    /// <summary>
+    /// This class is a callback invoked when a client sends asset data to
+    /// a task inventory script update url
+    /// </summary>
+    public class TaskInventoryScriptUpdater
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public event UpdateTaskScript OnUpLoad;
+
+        private UpdateTaskScript handlerUpdateTaskScript = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID inventoryItemID;
+        private UUID primID;
+        private bool isScriptRunning;
+        private IHttpServer httpListener;
+        private bool m_dumpAssetToFile;
+
+        public TaskInventoryScriptUpdater(UUID inventoryItemID, UUID primID, int isScriptRunning,
+                                            string path, IHttpServer httpServer, bool dumpAssetToFile)
+        {
+            m_dumpAssetToFile = dumpAssetToFile;
+
+            this.inventoryItemID = inventoryItemID;
+            this.primID = primID;
+
+            // This comes in over the packet as an integer, but actually appears to be treated as a bool
+            this.isScriptRunning = (0 == isScriptRunning ? false : true);
+
+            uploaderPath = path;
+            httpListener = httpServer;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            try
+            {
+                //                    m_log.InfoFormat("[CAPS]: " +
+                //                                     "TaskInventoryScriptUpdater received data: {0}, path: {1}, param: {2}",
+                //                                     data, path, param));
+
+                string res = String.Empty;
+                LLSDTaskScriptUploadComplete uploadComplete = new LLSDTaskScriptUploadComplete();
+
+                ArrayList errors = new ArrayList();
+                handlerUpdateTaskScript = OnUpLoad;
+                if (handlerUpdateTaskScript != null)
+                {
+                    handlerUpdateTaskScript(inventoryItemID, primID, isScriptRunning, data, ref errors);
+                }
+
+                uploadComplete.new_asset = inventoryItemID;
+                uploadComplete.compiled = errors.Count > 0 ? false : true;
+                uploadComplete.state = "complete";
+                uploadComplete.errors = new OpenSim.Framework.Capabilities.OSDArray();
+                uploadComplete.errors.Array = errors;
+
+                res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+                httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+                if (m_dumpAssetToFile)
+                {
+                    SaveAssetToFile("updatedtaskscript" + Util.RandomClass.Next(1, 1000) + ".dat", data);
+                }
+
+                //                    m_log.InfoFormat("[CAPS]: TaskInventoryScriptUpdater.uploaderCaps res: {0}", res);
+
+                return res;
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+
+            // XXX Maybe this should be some meaningful error packet
+            return null;
+        }
+
+        ///Left this in and commented in case there are unforseen issues
+        //private void SaveAssetToFile(string filename, byte[] data)
+        //{
+        //    FileStream fs = File.Create(filename);
+        //    BinaryWriter bw = new BinaryWriter(fs);
+        //    bw.Write(data);
+        //    bw.Close();
+        //    fs.Close();
+        //}
+        private static void SaveAssetToFile(string filename, byte[] data)
+        {
+            string assetPath = "UserAssets";
+            if (!Directory.Exists(assetPath))
+            {
+                Directory.CreateDirectory(assetPath);
+            }
+            FileStream fs = File.Create(Path.Combine(assetPath, filename));
+            BinaryWriter bw = new BinaryWriter(fs);
+            bw.Write(data);
+            bw.Close();
+            fs.Close();
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/TestLLPacketServer.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs
index e995d65..66b865f 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/TestLLPacketServer.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs
@@ -25,48 +25,67 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System;
 using System.Collections.Generic;
-using OpenMetaverse.Packets;
+using System.Reflection;
 
-namespace OpenSim.Region.ClientStack.LindenUDP.Tests
-{ 
-    public class TestLLPacketServer : LLPacketServer
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using Mono.Addins;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+[assembly: Addin("LindenCaps", "0.1")]
+[assembly: AddinDependency("OpenSim", "0.5")]
+namespace OpenSim.Region.ClientStack.Linden
+{
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class BunchOfCapsModule : INonSharedRegionModule
     {
-        /// <summary>
-        /// Record counts of packets received
-        /// </summary>
-        protected Dictionary<PacketType, int> m_packetsReceived = new Dictionary<PacketType, int>();
-        
-        public TestLLPacketServer(LLUDPServer networkHandler, ClientStackUserSettings userSettings)
-            : base(networkHandler, userSettings)
-        {}
-        
-        public override void InPacket(uint circuitCode, Packet packet)
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_Scene;
+
+        #region INonSharedRegionModule
+
+        public string Name { get { return "BunchOfCapsModule"; } }
+
+        public Type ReplaceableInterface { get { return null; } }
+
+        public void Initialise(IConfigSource source)
         {
-            base.InPacket(circuitCode, packet);
-            
-            if (m_packetsReceived.ContainsKey(packet.Type))
-                m_packetsReceived[packet.Type]++;
-            else
-                m_packetsReceived[packet.Type] = 1;
         }
-        
-        public int GetTotalPacketsReceived()
+
+        public void Close() { } 
+
+        public void AddRegion(Scene scene)
         {
-            int totalCount = 0;
-            
-            foreach (int count in m_packetsReceived.Values)
-                totalCount += count;
-            
-            return totalCount;
+            m_Scene = scene;
+            m_Scene.EventManager.OnRegisterCaps += OnRegisterCaps;
         }
-        
-        public int GetPacketsReceivedFor(PacketType packetType)
+
+        public void RemoveRegion(Scene scene)
         {
-            if (m_packetsReceived.ContainsKey(packetType))
-                return m_packetsReceived[packetType];
-            else
-                return 0;
         }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public void PostInitialise() { }
+        #endregion 
+
+        private void OnRegisterCaps(UUID agentID, Caps caps)
+        {
+            new BunchOfCaps(m_Scene, caps);
+        }
+
     }
 }
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
new file mode 100644
index 0000000..8ba6f61
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
@@ -0,0 +1,809 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+using System.Threading;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.Messages.Linden;
+using OpenMetaverse.Packets;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using BlockingLLSDQueue = OpenSim.Framework.BlockingQueue<OpenMetaverse.StructuredData.OSD>;
+using Caps=OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public struct QueueItem
+    {
+        public int id;
+        public OSDMap body;
+    }
+
+    //[Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class EventQueueGetModule : IEventQueue, IRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <value>
+        /// Debug level.
+        /// </value>
+        public int DebugLevel { get; set; }
+
+        protected Scene m_scene;
+        private IConfigSource m_gConfig;
+        bool enabledYN;
+        
+        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 IRegionModule methods
+        public virtual void Initialise(Scene scene, IConfigSource config)
+        {
+            m_gConfig = config;
+
+            IConfig startupConfig = m_gConfig.Configs["Startup"];
+
+            ReadConfigAndPopulate(scene, startupConfig, "Startup");
+
+            if (enabledYN)
+            {
+                m_scene = scene;
+                scene.RegisterModuleInterface<IEventQueue>(this);
+                
+                // Register fallback handler
+                // Why does EQG Fail on region crossings!
+                
+                //scene.CommsManager.HttpServer.AddLLSDHandler("/CAPS/EQG/", EventQueueFallBack);
+
+                scene.EventManager.OnNewClient += OnNewClient;
+
+                // TODO: Leaving these open, or closing them when we
+                // become a child is incorrect. It messes up TP in a big
+                // way. CAPS/EQ need to be active as long as the UDP
+                // circuit is there.
+
+                scene.EventManager.OnClientClosed += ClientClosed;
+                scene.EventManager.OnMakeChildAgent += MakeChildAgent;
+                scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+
+                MainConsole.Instance.Commands.AddCommand(
+                    "event queue",
+                    false,
+                    "debug eq",
+                    "debug eq [0|1]",
+                    "Turn on event queue debugging",                                   
+                    "debug eq 1 will turn on event queue debugging.  This will log all outgoing event queue messages to clients.\n"
+                        + "debug eq 0 will turn off event queue debugging.",
+                    HandleDebugEq);
+            }
+            else
+            {
+                m_gConfig = null;
+            }
+        }
+
+        private void ReadConfigAndPopulate(Scene scene, IConfig startupConfig, string p)
+        {
+            enabledYN = startupConfig.GetBoolean("EventQueue", true);
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public virtual void Close()
+        {
+        }
+
+        public virtual string Name
+        {
+            get { return "EventQueueGetModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+        #endregion
+
+        protected void HandleDebugEq(string module, string[] args)
+        {
+            int debugLevel;
+
+            if (!(args.Length == 3 && int.TryParse(args[2], out debugLevel)))
+            {
+                MainConsole.Instance.OutputFormat("Usage: debug eq [0|1]");
+            }
+            else
+            {
+                DebugLevel = debugLevel;
+                MainConsole.Instance.OutputFormat(
+                    "Set event queue debug level to {0} in {1}", DebugLevel, m_scene.RegionInfo.RegionName);
+            }
+        }
+
+        /// <summary>
+        ///  Always returns a valid queue
+        /// </summary>
+        /// <param name="agentId"></param>
+        /// <returns></returns>
+        private Queue<OSD> TryGetQueue(UUID agentId)
+        {
+            lock (queues)
+            {
+                if (!queues.ContainsKey(agentId))
+                {
+                    /*
+                    m_log.DebugFormat(
+                        "[EVENTQUEUE]: Adding new queue for agent {0} in region {1}", 
+                        agentId, m_scene.RegionInfo.RegionName);
+                    */
+                    queues[agentId] = new Queue<OSD>();
+                }
+                
+                return queues[agentId];
+            }
+        }
+
+        /// <summary>
+        /// May return a null queue
+        /// </summary>
+        /// <param name="agentId"></param>
+        /// <returns></returns>
+        private Queue<OSD> GetQueue(UUID agentId)
+        {
+            lock (queues)
+            {
+                if (queues.ContainsKey(agentId))
+                {
+                    return queues[agentId];
+                }
+                else
+                    return null;
+            }
+        }
+
+        #region IEventQueue Members
+
+        public bool Enqueue(OSD ev, UUID avatarID)
+        {
+            //m_log.DebugFormat("[EVENTQUEUE]: Enqueuing event for {0} in region {1}", avatarID, m_scene.RegionInfo.RegionName);
+            try
+            {
+                Queue<OSD> queue = GetQueue(avatarID);
+                if (queue != null)
+                    lock (queue)
+                        queue.Enqueue(ev);
+            } 
+            catch (NullReferenceException e)
+            {
+                m_log.Error("[EVENTQUEUE] Caught exception: " + e);
+                return false;
+            }
+            
+            return true;
+        }
+
+        #endregion
+
+        private void OnNewClient(IClientAPI client)
+        {
+            //client.OnLogout += ClientClosed;
+        }
+
+//        private void ClientClosed(IClientAPI client)
+//        {
+//            ClientClosed(client.AgentId);
+//        }
+
+        private void ClientClosed(UUID AgentID, Scene scene)
+        {
+//            m_log.DebugFormat("[EVENTQUEUE]: Closed client {0} in region {1}", AgentID, m_scene.RegionInfo.RegionName);
+
+            int count = 0;
+            while (queues.ContainsKey(AgentID) && queues[AgentID].Count > 0 && count++ < 5)
+            {
+                Thread.Sleep(1000);
+            }
+
+            lock (queues)
+            {
+                queues.Remove(AgentID);
+            }
+
+            List<UUID> removeitems = new List<UUID>();
+            lock (m_AvatarQueueUUIDMapping)
+            {
+                foreach (UUID ky in m_AvatarQueueUUIDMapping.Keys)
+                {
+//                    m_log.DebugFormat("[EVENTQUEUE]: Found key {0} in m_AvatarQueueUUIDMapping while looking for {1}", ky, AgentID);
+                    if (ky == AgentID)
+                    {
+                        removeitems.Add(ky);
+                    }
+                }
+
+                foreach (UUID ky in removeitems)
+                {
+                    UUID eventQueueGetUuid = m_AvatarQueueUUIDMapping[ky];
+                    m_AvatarQueueUUIDMapping.Remove(ky);
+
+                    MainServer.Instance.RemovePollServiceHTTPHandler("","/CAPS/EQG/" + eventQueueGetUuid.ToString() + "/");
+                }
+            }
+
+            UUID searchval = UUID.Zero;
+
+            removeitems.Clear();
+            
+            lock (m_QueueUUIDAvatarMapping)
+            {
+                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);
+            }
+        }
+
+        private void MakeChildAgent(ScenePresence avatar)
+        {
+            //m_log.DebugFormat("[EVENTQUEUE]: Make Child agent {0} in region {1}.", avatar.UUID, m_scene.RegionInfo.RegionName);
+            //lock (m_ids)
+           // {
+                //if (m_ids.ContainsKey(avatar.UUID))
+                //{
+                    // close the event queue.
+                    //m_ids[avatar.UUID] = -1;
+                //}
+            //}
+        }
+
+        public void OnRegisterCaps(UUID agentID, Caps caps)
+        {
+            // Register an event queue for the client
+
+            //m_log.DebugFormat(
+            //    "[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);
+
+            string capsBase = "/CAPS/EQG/";
+            UUID EventQueueGetUUID = UUID.Zero;
+
+            lock (m_AvatarQueueUUIDMapping)
+            {
+                // Reuse open queues.  The client does!
+                if (m_AvatarQueueUUIDMapping.ContainsKey(agentID))
+                {
+                    //m_log.DebugFormat("[EVENTQUEUE]: Found Existing UUID!");
+                    EventQueueGetUUID = m_AvatarQueueUUIDMapping[agentID];
+                }
+                else
+                {
+                    EventQueueGetUUID = UUID.Random();
+                    //m_log.DebugFormat("[EVENTQUEUE]: Using random UUID!");
+                }
+            }
+
+            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);
+            }
+
+            // Register this as a caps handler
+            // FIXME: Confusingly, we need to register separate as a capability so that the client is told about
+            // EventQueueGet when it receive capability information, but then we replace the rest handler immediately
+            // afterwards with the poll service.  So for now, we'll pass a null instead to simplify code reading, but
+            // really it should be possible to directly register the poll handler as a capability.
+            caps.RegisterHandler("EventQueueGet",
+                                 new RestHTTPHandler("POST", capsBase + EventQueueGetUUID.ToString() + "/", null));
+//                                                       delegate(Hashtable m_dhttpMethod)
+//                                                       {
+//                                                           return ProcessQueue(m_dhttpMethod, agentID, caps);
+//                                                       }));
+
+            // This will persist this beyond the expiry of the caps handlers
+            MainServer.Instance.AddPollServiceHTTPHandler(
+                capsBase + EventQueueGetUUID.ToString() + "/",
+                new PollServiceEventArgs(null, HasEvents, GetEvents, NoEvents, agentID));
+
+            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)
+                    return queue.Count > 0;
+
+            return false;
+        }
+
+        public Hashtable GetEvents(UUID requestID, UUID pAgentId, string request)
+        {
+//            m_log.DebugFormat("[EVENT QUEUE GET MODULE]: Invoked GetEvents() for {0}", pAgentId);
+
+            Queue<OSD> queue = TryGetQueue(pAgentId);
+            OSD element;
+            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 && element is OSDMap)
+                {
+                    OSDMap ev = (OSDMap)element;
+                    m_log.DebugFormat(
+                        "[EVENT QUEUE GET MODULE]: Eq OUT {0} to {1}",
+                        ev["message"], m_scene.GetScenePresence(pAgentId).Name);
+                }
+
+                array.Add(element);
+
+                lock (queue)
+                {
+                    while (queue.Count > 0)
+                    {
+                        element = queue.Dequeue();
+
+                        if (DebugLevel > 0 && element is OSDMap)
+                        {
+                            OSDMap ev = (OSDMap)element;
+                            m_log.DebugFormat(
+                                "[EVENT QUEUE GET MODULE]: Eq OUT {0} to {1}",
+                                ev["message"], m_scene.GetScenePresence(pAgentId).Name);
+                        }
+
+                        array.Add(element);
+                        thisID++;
+                    }
+                }
+            }
+
+            OSDMap events = new OSDMap();
+            events.Add("events", array);
+
+            events.Add("id", new OSDInteger(thisID));
+            lock (m_ids)
+            {
+                m_ids[pAgentId] = thisID + 1;
+            }
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 200;
+            responsedata["content_type"] = "application/xml";
+            responsedata["keepalive"] = false;
+            responsedata["reusecontext"] = false;
+            responsedata["str_response_string"] = OSDParser.SerializeLLSDXmlString(events);
+            //m_log.DebugFormat("[EVENTQUEUE]: sending response for {0} in region {1}: {2}", pAgentId, m_scene.RegionInfo.RegionName, responsedata["str_response_string"]);
+            return responsedata;
+        }
+
+        public Hashtable NoEvents(UUID requestID, UUID agentID)
+        {
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 502;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["reusecontext"] = false;
+            responsedata["str_response_string"] = "Upstream error: ";
+            responsedata["error_status_text"] = "Upstream error:";
+            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!");
+        }
+
+        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)
+        {
+            OSD item = EventQueueHelper.EnableSimulator(handle, endPoint);
+            Enqueue(item, avatarID);
+        }
+
+        public virtual void EstablishAgentCommunication(UUID avatarID, IPEndPoint endPoint, string capsPath) 
+        {
+            OSD item = EventQueueHelper.EstablishAgentCommunication(avatarID, endPoint.ToString(), capsPath);
+            Enqueue(item, avatarID);
+        }
+
+        public virtual void TeleportFinishEvent(ulong regionHandle, byte simAccess, 
+                                        IPEndPoint regionExternalEndPoint,
+                                        uint locationID, uint flags, string capsURL, 
+                                        UUID avatarID)
+        {
+            OSD item = EventQueueHelper.TeleportFinishEvent(regionHandle, simAccess, regionExternalEndPoint,
+                                                            locationID, flags, capsURL, avatarID);
+            Enqueue(item, avatarID);
+        }
+
+        public virtual void CrossRegion(ulong handle, Vector3 pos, Vector3 lookAt,
+                                IPEndPoint newRegionExternalEndPoint,
+                                string capsURL, UUID avatarID, UUID sessionID)
+        {
+            OSD item = EventQueueHelper.CrossRegion(handle, pos, lookAt, newRegionExternalEndPoint,
+                                                    capsURL, avatarID, sessionID);
+            Enqueue(item, avatarID);
+        }
+
+        public void ChatterboxInvitation(UUID sessionID, string sessionName,
+                                         UUID fromAgent, string message, UUID toAgent, string fromName, byte dialog,
+                                         uint timeStamp, bool offline, int parentEstateID, Vector3 position,
+                                         uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket)
+        {
+            OSD item = EventQueueHelper.ChatterboxInvitation(sessionID, sessionName, fromAgent, message, toAgent, fromName, dialog, 
+                                                             timeStamp, offline, parentEstateID, position, ttl, transactionID, 
+                                                             fromGroup, binaryBucket);
+            Enqueue(item, toAgent);
+            //m_log.InfoFormat("########### eq ChatterboxInvitation #############\n{0}", item);
+
+        }
+
+        public void ChatterBoxSessionAgentListUpdates(UUID sessionID, UUID fromAgent, UUID toAgent, bool canVoiceChat, 
+                                                      bool isModerator, bool textMute)
+        {
+            OSD item = EventQueueHelper.ChatterBoxSessionAgentListUpdates(sessionID, fromAgent, canVoiceChat,
+                                                                          isModerator, textMute);
+            Enqueue(item, toAgent);
+            //m_log.InfoFormat("########### eq ChatterBoxSessionAgentListUpdates #############\n{0}", item);
+        }
+
+        public void ParcelProperties(ParcelPropertiesMessage parcelPropertiesMessage, UUID avatarID)
+        {
+            OSD item = EventQueueHelper.ParcelProperties(parcelPropertiesMessage);
+            Enqueue(item, avatarID);
+        }
+
+        public void GroupMembership(AgentGroupDataUpdatePacket groupUpdate, UUID avatarID)
+        {
+            OSD item = EventQueueHelper.GroupMembership(groupUpdate);
+            Enqueue(item, avatarID);
+        }
+
+        public void QueryReply(PlacesReplyPacket groupUpdate, UUID avatarID)
+        {
+            OSD item = EventQueueHelper.PlacesQuery(groupUpdate);
+            Enqueue(item, avatarID);
+        }
+
+        public OSD ScriptRunningEvent(UUID objectID, UUID itemID, bool running, bool mono)
+        {
+            return EventQueueHelper.ScriptRunningReplyEvent(objectID, itemID, running, mono);
+        }
+
+        public OSD BuildEvent(string eventName, OSD eventBody)
+        {
+            return EventQueueHelper.BuildEvent(eventName, eventBody);
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
new file mode 100644
index 0000000..3f49aba
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
@@ -0,0 +1,399 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Net;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Messages.Linden;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public class EventQueueHelper
+    {
+        private EventQueueHelper() {} // no construction possible, it's an utility class
+
+        private static byte[] ulongToByteArray(ulong uLongValue)
+        {
+            // Reverse endianness of RegionHandle
+            return new byte[]
+            {
+                (byte)((uLongValue >> 56) % 256),
+                (byte)((uLongValue >> 48) % 256),
+                (byte)((uLongValue >> 40) % 256),
+                (byte)((uLongValue >> 32) % 256),
+                (byte)((uLongValue >> 24) % 256),
+                (byte)((uLongValue >> 16) % 256),
+                (byte)((uLongValue >> 8) % 256),
+                (byte)(uLongValue % 256)
+            };
+        }
+
+//        private static byte[] uintToByteArray(uint uIntValue)
+//        {
+//            byte[] result = new byte[4];
+//            Utils.UIntToBytesBig(uIntValue, result, 0);
+//            return result;
+//        }
+
+        public static OSD BuildEvent(string eventName, OSD eventBody)
+        {
+            OSDMap llsdEvent = new OSDMap(2);
+            llsdEvent.Add("message", new OSDString(eventName));
+            llsdEvent.Add("body", eventBody);
+
+            return llsdEvent;
+        }
+
+        public static OSD EnableSimulator(ulong handle, IPEndPoint endPoint)
+        {
+            OSDMap llsdSimInfo = new OSDMap(3);
+
+            llsdSimInfo.Add("Handle", new OSDBinary(ulongToByteArray(handle)));
+            llsdSimInfo.Add("IP", new OSDBinary(endPoint.Address.GetAddressBytes()));
+            llsdSimInfo.Add("Port", new OSDInteger(endPoint.Port));
+
+            OSDArray arr = new OSDArray(1);
+            arr.Add(llsdSimInfo);
+
+            OSDMap llsdBody = new OSDMap(1);
+            llsdBody.Add("SimulatorInfo", arr);
+
+            return BuildEvent("EnableSimulator", llsdBody);
+        }
+
+        public static OSD DisableSimulator(ulong handle)
+        {
+            //OSDMap llsdSimInfo = new OSDMap(1);
+
+            //llsdSimInfo.Add("Handle", new OSDBinary(regionHandleToByteArray(handle)));
+
+            //OSDArray arr = new OSDArray(1);
+            //arr.Add(llsdSimInfo);
+
+            OSDMap llsdBody = new OSDMap(0);
+            //llsdBody.Add("SimulatorInfo", arr);
+
+            return BuildEvent("DisableSimulator", llsdBody);
+        }
+        
+        public static OSD CrossRegion(ulong handle, Vector3 pos, Vector3 lookAt,
+                                      IPEndPoint newRegionExternalEndPoint,
+                                      string capsURL, UUID agentID, UUID sessionID)
+        {
+            OSDArray lookAtArr = new OSDArray(3);
+            lookAtArr.Add(OSD.FromReal(lookAt.X));
+            lookAtArr.Add(OSD.FromReal(lookAt.Y));
+            lookAtArr.Add(OSD.FromReal(lookAt.Z));
+
+            OSDArray positionArr = new OSDArray(3);
+            positionArr.Add(OSD.FromReal(pos.X));
+            positionArr.Add(OSD.FromReal(pos.Y));
+            positionArr.Add(OSD.FromReal(pos.Z));
+
+            OSDMap infoMap = new OSDMap(2);
+            infoMap.Add("LookAt", lookAtArr);
+            infoMap.Add("Position", positionArr);
+
+            OSDArray infoArr = new OSDArray(1);
+            infoArr.Add(infoMap);
+
+            OSDMap agentDataMap = new OSDMap(2);
+            agentDataMap.Add("AgentID", OSD.FromUUID(agentID));
+            agentDataMap.Add("SessionID",  OSD.FromUUID(sessionID));
+
+            OSDArray agentDataArr = new OSDArray(1);
+            agentDataArr.Add(agentDataMap);
+
+            OSDMap regionDataMap = new OSDMap(4);
+            regionDataMap.Add("RegionHandle", OSD.FromBinary(ulongToByteArray(handle)));
+            regionDataMap.Add("SeedCapability", OSD.FromString(capsURL));
+            regionDataMap.Add("SimIP", OSD.FromBinary(newRegionExternalEndPoint.Address.GetAddressBytes()));
+            regionDataMap.Add("SimPort", OSD.FromInteger(newRegionExternalEndPoint.Port));
+
+            OSDArray regionDataArr = new OSDArray(1);
+            regionDataArr.Add(regionDataMap);
+
+            OSDMap llsdBody = new OSDMap(3);
+            llsdBody.Add("Info", infoArr);
+            llsdBody.Add("AgentData", agentDataArr);
+            llsdBody.Add("RegionData", regionDataArr);
+
+            return BuildEvent("CrossedRegion", llsdBody);
+        }
+
+        public static OSD TeleportFinishEvent(
+            ulong regionHandle, byte simAccess, IPEndPoint regionExternalEndPoint,
+            uint locationID, uint flags, string capsURL, UUID agentID)
+        {
+            OSDMap info = new OSDMap();
+            info.Add("AgentID", OSD.FromUUID(agentID));
+            info.Add("LocationID", OSD.FromInteger(4)); // TODO what is this?
+            info.Add("RegionHandle", OSD.FromBinary(ulongToByteArray(regionHandle)));
+            info.Add("SeedCapability", OSD.FromString(capsURL));
+            info.Add("SimAccess", OSD.FromInteger(simAccess));
+            info.Add("SimIP", OSD.FromBinary(regionExternalEndPoint.Address.GetAddressBytes()));
+            info.Add("SimPort", OSD.FromInteger(regionExternalEndPoint.Port));
+            info.Add("TeleportFlags", OSD.FromULong(1L << 4)); // AgentManager.TeleportFlags.ViaLocation
+
+            OSDArray infoArr = new OSDArray();
+            infoArr.Add(info);
+
+            OSDMap body = new OSDMap();
+            body.Add("Info", infoArr);
+
+            return BuildEvent("TeleportFinish", body);
+        }
+
+        public static OSD ScriptRunningReplyEvent(UUID objectID, UUID itemID, bool running, bool mono)
+        {
+            OSDMap script = new OSDMap();
+            script.Add("ObjectID", OSD.FromUUID(objectID));
+            script.Add("ItemID", OSD.FromUUID(itemID));
+            script.Add("Running", OSD.FromBoolean(running));
+            script.Add("Mono", OSD.FromBoolean(mono));
+            
+            OSDArray scriptArr = new OSDArray();
+            scriptArr.Add(script);
+            
+            OSDMap body = new OSDMap();
+            body.Add("Script", scriptArr);
+            
+            return BuildEvent("ScriptRunningReply", body);
+        }
+
+        public static OSD EstablishAgentCommunication(UUID agentID, string simIpAndPort, string seedcap)
+        {
+            OSDMap body = new OSDMap(3);
+            body.Add("agent-id", new OSDUUID(agentID));
+            body.Add("sim-ip-and-port", new OSDString(simIpAndPort));
+            body.Add("seed-capability", new OSDString(seedcap));
+
+            return BuildEvent("EstablishAgentCommunication", body);
+        }
+
+        public static OSD KeepAliveEvent()
+        {
+            return BuildEvent("FAKEEVENT", new OSDMap());
+        }
+
+        public static OSD AgentParams(UUID agentID, bool checkEstate, int godLevel, bool limitedToEstate)
+        {
+            OSDMap body = new OSDMap(4);
+
+            body.Add("agent_id", new OSDUUID(agentID));
+            body.Add("check_estate", new OSDInteger(checkEstate ? 1 : 0));
+            body.Add("god_level", new OSDInteger(godLevel));
+            body.Add("limited_to_estate", new OSDInteger(limitedToEstate ? 1 : 0));
+
+            return body;
+        }
+
+        public static OSD InstantMessageParams(UUID fromAgent, string message, UUID toAgent,
+            string fromName, byte dialog, uint timeStamp, bool offline, int parentEstateID,
+            Vector3 position, uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket)
+        {
+            OSDMap messageParams = new OSDMap(15);
+            messageParams.Add("type", new OSDInteger((int)dialog));
+            
+            OSDArray positionArray = new OSDArray(3);
+            positionArray.Add(OSD.FromReal(position.X));
+            positionArray.Add(OSD.FromReal(position.Y));
+            positionArray.Add(OSD.FromReal(position.Z));
+            messageParams.Add("position", positionArray);
+
+            messageParams.Add("region_id", new OSDUUID(UUID.Zero));
+            messageParams.Add("to_id", new OSDUUID(toAgent));
+            messageParams.Add("source", new OSDInteger(0));
+
+            OSDMap data = new OSDMap(1);
+            data.Add("binary_bucket", OSD.FromBinary(binaryBucket));
+            messageParams.Add("data", data);
+            messageParams.Add("message", new OSDString(message));
+            messageParams.Add("id", new OSDUUID(transactionID));
+            messageParams.Add("from_name", new OSDString(fromName));
+            messageParams.Add("timestamp", new OSDInteger((int)timeStamp));
+            messageParams.Add("offline", new OSDInteger(offline ? 1 : 0));
+            messageParams.Add("parent_estate_id", new OSDInteger(parentEstateID));
+            messageParams.Add("ttl", new OSDInteger((int)ttl));
+            messageParams.Add("from_id", new OSDUUID(fromAgent));
+            messageParams.Add("from_group", new OSDInteger(fromGroup ? 1 : 0));
+
+            return messageParams;
+        }
+
+        public static OSD InstantMessage(UUID fromAgent, string message, UUID toAgent,
+            string fromName, byte dialog, uint timeStamp, bool offline, int parentEstateID,
+            Vector3 position, uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket,
+            bool checkEstate, int godLevel, bool limitedToEstate)
+        {
+            OSDMap im = new OSDMap(2);
+            im.Add("message_params", InstantMessageParams(fromAgent, message, toAgent,
+            fromName, dialog, timeStamp, offline, parentEstateID,
+            position, ttl, transactionID, fromGroup, binaryBucket));
+
+            im.Add("agent_params", AgentParams(fromAgent, checkEstate, godLevel, limitedToEstate));
+
+            return im;
+        }
+
+
+        public static OSD ChatterboxInvitation(UUID sessionID, string sessionName,
+            UUID fromAgent, string message, UUID toAgent, string fromName, byte dialog,
+            uint timeStamp, bool offline, int parentEstateID, Vector3 position,
+            uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket)
+        {
+            OSDMap body = new OSDMap(5);
+            body.Add("session_id", new OSDUUID(sessionID));
+            body.Add("from_name", new OSDString(fromName));
+            body.Add("session_name", new OSDString(sessionName));
+            body.Add("from_id", new OSDUUID(fromAgent));
+
+            body.Add("instantmessage", InstantMessage(fromAgent, message, toAgent,
+            fromName, dialog, timeStamp, offline, parentEstateID, position,
+            ttl, transactionID, fromGroup, binaryBucket, true, 0, true));
+
+            OSDMap chatterboxInvitation = new OSDMap(2);
+            chatterboxInvitation.Add("message", new OSDString("ChatterBoxInvitation"));
+            chatterboxInvitation.Add("body", body);
+            return chatterboxInvitation;
+        }
+
+        public static OSD ChatterBoxSessionAgentListUpdates(UUID sessionID,
+            UUID agentID, bool canVoiceChat, bool isModerator, bool textMute)
+        {
+            OSDMap body = new OSDMap();
+            OSDMap agentUpdates = new OSDMap();
+            OSDMap infoDetail = new OSDMap();
+            OSDMap mutes = new OSDMap();
+
+            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);
+            agentUpdates.Add(agentID.ToString(), info);
+            body.Add("agent_updates", agentUpdates);
+            body.Add("session_id", OSD.FromUUID(sessionID));
+            body.Add("updates", new OSD());
+
+            OSDMap chatterBoxSessionAgentListUpdates = new OSDMap();
+            chatterBoxSessionAgentListUpdates.Add("message", OSD.FromString("ChatterBoxSessionAgentListUpdates"));
+            chatterBoxSessionAgentListUpdates.Add("body", body);
+
+            return chatterBoxSessionAgentListUpdates;
+        }
+
+        public static OSD GroupMembership(AgentGroupDataUpdatePacket groupUpdatePacket)
+        {
+            OSDMap groupUpdate = new OSDMap();
+            groupUpdate.Add("message", OSD.FromString("AgentGroupDataUpdate"));
+
+            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);
+
+            OSDArray groupData = new OSDArray();
+
+            foreach (AgentGroupDataUpdatePacket.GroupDataBlock groupDataBlock in groupUpdatePacket.GroupData)
+            {
+                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));
+
+                groupData.Add(groupDataMap);
+
+            }
+            body.Add("GroupData", groupData);
+            groupUpdate.Add("body", body);
+
+            return groupUpdate;
+        }
+        
+        public static OSD PlacesQuery(PlacesReplyPacket PlacesReply)
+        {
+            OSDMap placesReply = new OSDMap();
+            placesReply.Add("message", OSD.FromString("PlacesReplyMessage"));
+
+            OSDMap body = new OSDMap();
+            OSDArray agentData = new OSDArray();
+            OSDMap agentDataMap = new OSDMap();
+            agentDataMap.Add("AgentID", OSD.FromUUID(PlacesReply.AgentData.AgentID));
+            agentDataMap.Add("QueryID", OSD.FromUUID(PlacesReply.AgentData.QueryID));
+            agentDataMap.Add("TransactionID", OSD.FromUUID(PlacesReply.TransactionData.TransactionID));
+            agentData.Add(agentDataMap);
+            body.Add("AgentData", agentData);
+
+            OSDArray QueryData = new OSDArray();
+
+            foreach (PlacesReplyPacket.QueryDataBlock groupDataBlock in PlacesReply.QueryData)
+            {
+                OSDMap QueryDataMap = new OSDMap();
+                QueryDataMap.Add("ActualArea", OSD.FromInteger(groupDataBlock.ActualArea));
+                QueryDataMap.Add("BillableArea", OSD.FromInteger(groupDataBlock.BillableArea));
+                QueryDataMap.Add("Description", OSD.FromBinary(groupDataBlock.Desc));
+                QueryDataMap.Add("Dwell", OSD.FromInteger((int)groupDataBlock.Dwell));
+                QueryDataMap.Add("Flags", OSD.FromString(Convert.ToString(groupDataBlock.Flags)));
+                QueryDataMap.Add("GlobalX", OSD.FromInteger((int)groupDataBlock.GlobalX));
+                QueryDataMap.Add("GlobalY", OSD.FromInteger((int)groupDataBlock.GlobalY));
+                QueryDataMap.Add("GlobalZ", OSD.FromInteger((int)groupDataBlock.GlobalZ));
+                QueryDataMap.Add("Name", OSD.FromBinary(groupDataBlock.Name));
+                QueryDataMap.Add("OwnerID", OSD.FromUUID(groupDataBlock.OwnerID));
+                QueryDataMap.Add("SimName", OSD.FromBinary(groupDataBlock.SimName));
+                QueryDataMap.Add("SnapShotID", OSD.FromUUID(groupDataBlock.SnapshotID));
+                QueryDataMap.Add("ProductSku", OSD.FromInteger(0));
+                QueryDataMap.Add("Price", OSD.FromInteger(groupDataBlock.Price));
+                
+                QueryData.Add(QueryDataMap);
+            }
+            body.Add("QueryData", QueryData);
+            placesReply.Add("QueryData[]", body);
+
+            return placesReply;
+        }
+
+        public static OSD ParcelProperties(ParcelPropertiesMessage parcelPropertiesMessage)
+        {
+            OSDMap message = new OSDMap();
+            message.Add("message", OSD.FromString("ParcelProperties"));
+            OSD message_body = parcelPropertiesMessage.Serialize();
+            message.Add("body", message_body);
+            return message;
+        }
+
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs
new file mode 100644
index 0000000..a5209b7
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.ClientStack.Linden;
+using OpenSim.Region.CoreModules.Framework;
+using OpenSim.Tests.Common;
+using OpenSim.Tests.Common.Mock;
+
+namespace OpenSim.Region.ClientStack.Linden.Tests
+{
+    [TestFixture]
+    public class EventQueueTests
+    {
+        private TestScene m_scene;
+
+        [SetUp]
+        public void SetUp()
+        {
+            MainServer.Instance = new BaseHttpServer(9999, false, 9998, "");
+
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Startup");
+            config.Configs["Startup"].Set("EventQueue", "true");
+
+            CapabilitiesModule capsModule = new CapabilitiesModule();
+            EventQueueGetModule eqgModule = new EventQueueGetModule();
+
+            m_scene = SceneHelpers.SetupScene();
+            SceneHelpers.SetupSceneModules(m_scene, config, capsModule, eqgModule);
+        }
+
+        [Test]
+        public void AddForClient()
+        {
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            SceneHelpers.AddScenePresence(m_scene, TestHelpers.ParseTail(0x1));
+
+            // TODO: Add more assertions for the other aspects of event queues
+            Assert.That(MainServer.Instance.GetPollServiceHandlerKeys().Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void RemoveForClient()
+        {
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            UUID spId = TestHelpers.ParseTail(0x1);
+
+            SceneHelpers.AddScenePresence(m_scene, spId);
+            m_scene.IncomingCloseAgent(spId);
+
+            // TODO: Add more assertions for the other aspects of event queues
+            Assert.That(MainServer.Instance.GetPollServiceHandlerKeys().Count, Is.EqualTo(0));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
new file mode 100644
index 0000000..e7bd2e7
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using 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.Capabilities.Handlers;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class GetMeshModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private Scene m_scene;
+        private IAssetService m_AssetService;
+        private bool m_Enabled = true;
+        private string m_URL;
+
+        #region IRegionModuleBase Members
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_URL = config.GetString("Cap_GetMesh", string.Empty);
+            // Cap doesn't exist
+            if (m_URL != string.Empty)
+                m_Enabled = true;
+        }
+
+        public void AddRegion(Scene pScene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene = pScene;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_AssetService = m_scene.RequestModuleInterface<IAssetService>();
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+
+        public void Close() { }
+
+        public string Name { get { return "GetMeshModule"; } }
+
+        #endregion
+
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+//            UUID capID = UUID.Random();
+
+            //caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
+            if (m_URL == "localhost")
+            {
+//                m_log.DebugFormat("[GETMESH]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
+                GetMeshHandler gmeshHandler = new GetMeshHandler(m_AssetService);
+                IRequestHandler reqHandler = new RestHTTPHandler("GET", "/CAPS/" + UUID.Random(),
+                                                           delegate(Hashtable m_dhttpMethod)
+                                                           {
+                                                               return gmeshHandler.ProcessGetMesh(m_dhttpMethod, UUID.Zero, null);
+                                                           });
+
+                caps.RegisterHandler("GetMesh", reqHandler);
+            }
+            else
+            {
+//                m_log.DebugFormat("[GETMESH]: {0} in region {1}", m_URL, m_scene.RegionInfo.RegionName);
+                caps.RegisterHandler("GetMesh", m_URL);
+            }
+        }
+
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
new file mode 100644
index 0000000..fffcee2
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class GetTextureModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private Scene m_scene;
+        private IAssetService m_assetService;
+
+        private bool m_Enabled = false;
+
+        // TODO: Change this to a config option
+        const string REDIRECT_URL = null;
+
+        private string m_URL;
+
+        #region ISharedRegionModule Members
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_URL = config.GetString("Cap_GetTexture", string.Empty);
+            // Cap doesn't exist
+            if (m_URL != string.Empty)
+                m_Enabled = true;
+        }
+
+        public void AddRegion(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene = s;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "GetTextureModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capID = UUID.Random();
+
+            //caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
+            if (m_URL == "localhost")
+            {
+//                m_log.DebugFormat("[GETTEXTURE]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
+                caps.RegisterHandler("GetTexture", new GetTextureHandler("/CAPS/" + capID + "/", m_assetService));
+            }
+            else
+            {
+//                m_log.DebugFormat("[GETTEXTURE]: {0} in region {1}", m_URL, m_scene.RegionInfo.RegionName);
+                caps.RegisterHandler("GetTexture", m_URL);
+            }
+        }
+
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs
new file mode 100644
index 0000000..18c7eae
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    /// <summary>
+    /// MeshUploadFlag capability. This is required for uploading Mesh.
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class MeshUploadFlagModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Is this module enabled?
+        /// </summary>
+        public bool Enabled { get; private set; }
+
+        private Scene m_scene;
+        private UUID m_agentID;
+
+        #region ISharedRegionModule Members
+
+        public MeshUploadFlagModule()
+        {
+            Enabled = true;
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["Mesh"];
+            if (config == null)
+            {
+                return;
+            }
+            else
+            {
+                Enabled = config.GetBoolean("AllowMeshUpload", Enabled);
+            }
+        }
+
+        public void AddRegion(Scene s)
+        {
+            if (!Enabled)
+                return;
+
+            m_scene = s;
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            if (!Enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "MeshUploadFlagModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            IRequestHandler reqHandler = new RestHTTPHandler("GET", "/CAPS/" + UUID.Random(), MeshUploadFlag);
+            caps.RegisterHandler("MeshUploadFlag", reqHandler);
+                m_agentID = agentID;
+        }
+
+        private Hashtable MeshUploadFlag(Hashtable mDhttpMethod)
+        {
+//            m_log.DebugFormat("[MESH UPLOAD FLAG MODULE]: MeshUploadFlag request");
+
+            OSDMap data = new OSDMap();
+            ScenePresence sp = m_scene.GetScenePresence(m_agentID);
+            data["username"] = sp.Firstname + "." + sp.Lastname;
+            data["display_name_next_update"] = new OSDDate(DateTime.Now);
+            data["legacy_first_name"] = sp.Firstname;
+            data["mesh_upload_status"] = "valid";
+            data["display_name"] = sp.Firstname + " " + sp.Lastname;
+            data["legacy_last_name"] = sp.Lastname;
+            data["id"] = m_agentID;
+            data["is_display_name_default"] = true;
+
+            //Send back data
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 200; 
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = OSDParser.SerializeLLSDXmlString(data);
+            return responsedata;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
new file mode 100644
index 0000000..b2f04f9
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
@@ -0,0 +1,271 @@
+/*
+ * 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;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    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;
+
+        #region IRegionModuleBase 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);
+        }
+
+        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 IRegionModule Members
+
+       
+
+        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(),
+                                                                                           delegate(LLSDAssetUploadRequest req)
+                                                       {
+                                                           return NewAgentInventoryRequest(req,agentID);
+                                                       }));
+         
+        }
+
+        #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 and 
+
+
+            //if (llsdRequest.asset_type == "texture" ||
+           //     llsdRequest.asset_type == "animation" ||
+           //     llsdRequest.asset_type == "sound")
+           // {
+                IClientAPI client = null;
+
+                
+                IMoneyModule mm = m_scene.RequestModuleInterface<IMoneyModule>();
+                
+                if (mm != null)
+                {
+                    if (m_scene.TryGetClient(agentID, out client))
+                    {
+                        if (!mm.UploadCovered(client, 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));
+
+            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)
+        {
+            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.All;
+            item.BasePermissions = (uint)PermissionMask.All;
+            item.EveryOnePermissions = 0;
+            item.NextPermissions = (uint)PermissionMask.All;
+            item.CreationDate = Util.UnixTimeSinceEpoch();
+            m_scene.AddInventoryItem(item);
+            
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
new file mode 100644
index 0000000..1c47f0e
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
@@ -0,0 +1,368 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Caps=OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public class ObjectAdd : IRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private Scene m_scene;
+        #region IRegionModule Members
+
+        public void Initialise(Scene pScene, IConfigSource pSource)
+        {
+            m_scene = pScene;
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void PostInitialise()
+        {
+            
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capuuid = UUID.Random();
+            
+//            m_log.InfoFormat("[OBJECTADD]: {0}", "/CAPS/OA/" + capuuid + "/");
+
+            caps.RegisterHandler("ObjectAdd",
+                                 new RestHTTPHandler("POST", "/CAPS/OA/" + capuuid + "/",
+                                                       delegate(Hashtable m_dhttpMethod)
+                                                       {
+                                                           return ProcessAdd(m_dhttpMethod, agentID, caps);
+                                                       }));
+        }
+
+        public Hashtable ProcessAdd(Hashtable request, UUID AgentId, Caps cap)
+        {
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 400; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = "Request wasn't what was expected";
+            ScenePresence avatar;
+            
+            if (!m_scene.TryGetScenePresence(AgentId, out avatar))
+                return responsedata;
+
+
+            OSD r = OSDParser.DeserializeLLSDXml((string)request["requestbody"]);
+            //UUID session_id = UUID.Zero;
+            bool bypass_raycast = false;
+            uint everyone_mask = 0;
+            uint group_mask = 0;
+            uint next_owner_mask = 0;
+            uint flags = 0;
+            UUID group_id = UUID.Zero;
+            int hollow = 0;
+            int material = 0;
+            int p_code = 0;
+            int path_begin = 0;
+            int path_curve = 0;
+            int path_end = 0;
+            int path_radius_offset = 0;
+            int path_revolutions = 0;
+            int path_scale_x = 0;
+            int path_scale_y = 0;
+            int path_shear_x = 0;
+            int path_shear_y = 0;
+            int path_skew = 0;
+            int path_taper_x = 0;
+            int path_taper_y = 0;
+            int path_twist = 0;
+            int path_twist_begin = 0;
+            int profile_begin = 0;
+            int profile_curve = 0;
+            int profile_end = 0;
+            Vector3 ray_end = Vector3.Zero;
+            bool ray_end_is_intersection = false;
+            Vector3 ray_start = Vector3.Zero;
+            UUID ray_target_id = UUID.Zero;
+            Quaternion rotation = Quaternion.Identity;
+            Vector3 scale = Vector3.Zero;
+            int state = 0;
+
+            if (r.Type != OSDType.Map) // not a proper req
+                return responsedata;
+            
+            OSDMap rm = (OSDMap)r;
+
+            if (rm.ContainsKey("ObjectData")) //v2
+            {
+                if (rm["ObjectData"].Type != OSDType.Map)
+                {
+                    responsedata["str_response_string"] = "Has ObjectData key, but data not in expected format";
+                    return responsedata;
+                }
+
+                OSDMap ObjMap = (OSDMap) rm["ObjectData"];
+
+                bypass_raycast = ObjMap["BypassRaycast"].AsBoolean();
+                everyone_mask = readuintval(ObjMap["EveryoneMask"]);
+                flags = readuintval(ObjMap["Flags"]);
+                group_mask = readuintval(ObjMap["GroupMask"]);
+                material = ObjMap["Material"].AsInteger();
+                next_owner_mask = readuintval(ObjMap["NextOwnerMask"]);
+                p_code = ObjMap["PCode"].AsInteger();
+
+                if (ObjMap.ContainsKey("Path"))
+                {
+                    if (ObjMap["Path"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has Path key, but data not in expected format";
+                        return responsedata;
+                    }
+
+                    OSDMap PathMap = (OSDMap)ObjMap["Path"];
+                    path_begin = PathMap["Begin"].AsInteger();
+                    path_curve = PathMap["Curve"].AsInteger();
+                    path_end = PathMap["End"].AsInteger();
+                    path_radius_offset = PathMap["RadiusOffset"].AsInteger();
+                    path_revolutions = PathMap["Revolutions"].AsInteger();
+                    path_scale_x = PathMap["ScaleX"].AsInteger();
+                    path_scale_y = PathMap["ScaleY"].AsInteger();
+                    path_shear_x = PathMap["ShearX"].AsInteger();
+                    path_shear_y = PathMap["ShearY"].AsInteger();
+                    path_skew = PathMap["Skew"].AsInteger();
+                    path_taper_x = PathMap["TaperX"].AsInteger();
+                    path_taper_y = PathMap["TaperY"].AsInteger();
+                    path_twist = PathMap["Twist"].AsInteger();
+                    path_twist_begin = PathMap["TwistBegin"].AsInteger();
+
+                }
+
+                if (ObjMap.ContainsKey("Profile"))
+                {
+                    if (ObjMap["Profile"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has Profile key, but data not in expected format";
+                        return responsedata;
+                    }
+                        
+                    OSDMap ProfileMap = (OSDMap)ObjMap["Profile"];
+
+                    profile_begin = ProfileMap["Begin"].AsInteger();
+                    profile_curve = ProfileMap["Curve"].AsInteger();
+                    profile_end = ProfileMap["End"].AsInteger();
+                    hollow = ProfileMap["Hollow"].AsInteger();
+                }
+                ray_end_is_intersection = ObjMap["RayEndIsIntersection"].AsBoolean();
+                
+                ray_target_id = ObjMap["RayTargetId"].AsUUID();
+                state = ObjMap["State"].AsInteger();
+                try
+                {
+                    ray_end = ((OSDArray) ObjMap["RayEnd"]).AsVector3();
+                    ray_start = ((OSDArray) ObjMap["RayStart"]).AsVector3();
+                    scale = ((OSDArray) ObjMap["Scale"]).AsVector3();
+                    rotation = ((OSDArray)ObjMap["Rotation"]).AsQuaternion();
+                }
+                catch (Exception)
+                {
+                    responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format";
+                    return responsedata;
+                }
+
+                if (rm.ContainsKey("AgentData"))
+                {
+                    if (rm["AgentData"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has AgentData key, but data not in expected format";
+                        return responsedata;
+                    }
+
+                    OSDMap AgentDataMap = (OSDMap) rm["AgentData"];
+
+                    //session_id = AgentDataMap["SessionId"].AsUUID();
+                    group_id = AgentDataMap["GroupId"].AsUUID();
+                }
+
+            }
+            else
+            { //v1
+                bypass_raycast = rm["bypass_raycast"].AsBoolean();
+
+                everyone_mask = readuintval(rm["everyone_mask"]);
+                flags = readuintval(rm["flags"]);
+                group_id = rm["group_id"].AsUUID();
+                group_mask = readuintval(rm["group_mask"]);
+                hollow = rm["hollow"].AsInteger();
+                material = rm["material"].AsInteger();
+                next_owner_mask = readuintval(rm["next_owner_mask"]);
+                hollow = rm["hollow"].AsInteger();
+                p_code = rm["p_code"].AsInteger();
+                path_begin = rm["path_begin"].AsInteger();
+                path_curve = rm["path_curve"].AsInteger();
+                path_end = rm["path_end"].AsInteger();
+                path_radius_offset = rm["path_radius_offset"].AsInteger();
+                path_revolutions = rm["path_revolutions"].AsInteger();
+                path_scale_x = rm["path_scale_x"].AsInteger();
+                path_scale_y = rm["path_scale_y"].AsInteger();
+                path_shear_x = rm["path_shear_x"].AsInteger();
+                path_shear_y = rm["path_shear_y"].AsInteger();
+                path_skew = rm["path_skew"].AsInteger();
+                path_taper_x = rm["path_taper_x"].AsInteger();
+                path_taper_y = rm["path_taper_y"].AsInteger();
+                path_twist = rm["path_twist"].AsInteger();
+                path_twist_begin = rm["path_twist_begin"].AsInteger();
+                profile_begin = rm["profile_begin"].AsInteger();
+                profile_curve = rm["profile_curve"].AsInteger();
+                profile_end = rm["profile_end"].AsInteger();
+                
+                ray_end_is_intersection = rm["ray_end_is_intersection"].AsBoolean();
+                
+                ray_target_id = rm["ray_target_id"].AsUUID();
+                
+                
+                //session_id = rm["session_id"].AsUUID();
+                state = rm["state"].AsInteger();
+                try 
+                {
+                    ray_end = ((OSDArray)rm["ray_end"]).AsVector3();
+                    ray_start = ((OSDArray)rm["ray_start"]).AsVector3();
+                    rotation = ((OSDArray)rm["rotation"]).AsQuaternion();
+                    scale = ((OSDArray)rm["scale"]).AsVector3();
+                } 
+                catch (Exception)
+                {
+                    responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format";
+                    return responsedata;
+                }
+            }
+
+           
+
+            Vector3 pos = m_scene.GetNewRezLocation(ray_start, ray_end, ray_target_id, rotation, (bypass_raycast) ? (byte)1 : (byte)0,  (ray_end_is_intersection) ? (byte)1 : (byte)0, true, scale, false);
+
+            PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+
+            pbs.PathBegin = (ushort)path_begin;
+            pbs.PathCurve = (byte)path_curve;
+            pbs.PathEnd = (ushort)path_end;
+            pbs.PathRadiusOffset = (sbyte)path_radius_offset;
+            pbs.PathRevolutions = (byte)path_revolutions;
+            pbs.PathScaleX = (byte)path_scale_x;
+            pbs.PathScaleY = (byte)path_scale_y;
+            pbs.PathShearX = (byte) path_shear_x;
+            pbs.PathShearY = (byte)path_shear_y;
+            pbs.PathSkew = (sbyte)path_skew;
+            pbs.PathTaperX = (sbyte)path_taper_x;
+            pbs.PathTaperY = (sbyte)path_taper_y;
+            pbs.PathTwist = (sbyte)path_twist;
+            pbs.PathTwistBegin = (sbyte)path_twist_begin;
+            pbs.HollowShape = (HollowShape) hollow;
+            pbs.PCode = (byte)p_code;
+            pbs.ProfileBegin = (ushort) profile_begin;
+            pbs.ProfileCurve = (byte) profile_curve;
+            pbs.ProfileEnd = (ushort)profile_end;
+            pbs.Scale = scale;
+            pbs.State = (byte)state;
+
+            SceneObjectGroup obj = null; ;
+
+            if (m_scene.Permissions.CanRezObject(1, avatar.UUID, pos))
+            {
+                // rez ON the ground, not IN the ground
+               // pos.Z += 0.25F;
+
+                obj = m_scene.AddNewPrim(avatar.UUID, group_id, pos, rotation, pbs);
+            }
+
+
+            if (obj == null)
+                return responsedata;
+
+            SceneObjectPart rootpart = obj.RootPart;
+            rootpart.Shape = pbs;
+            rootpart.Flags |= (PrimFlags)flags;
+            rootpart.EveryoneMask = everyone_mask;
+            rootpart.GroupID = group_id;
+            rootpart.GroupMask = group_mask;
+            rootpart.NextOwnerMask = next_owner_mask;
+            rootpart.Material = (byte)material;
+            
+            m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
+            
+            responsedata["int_response_code"] = 200; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = String.Format("<llsd><map><key>local_id</key>{0}</map></llsd>",ConvertUintToBytes(obj.LocalId));
+
+            return responsedata;
+        }
+
+        private uint readuintval(OSD obj)
+        {
+            byte[] tmp = obj.AsBinary();
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(tmp);
+            return Utils.BytesToUInt(tmp);
+
+        }
+        private string ConvertUintToBytes(uint val)
+        {
+            byte[] resultbytes = Utils.UIntToBytes(val);
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(resultbytes);
+            return String.Format("<binary encoding=\"base64\">{0}</binary>",Convert.ToBase64String(resultbytes));
+        }
+
+        public void Close()
+        {
+            
+        }
+
+        public string Name
+        {
+            get { return "ObjectAddModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs
new file mode 100644
index 0000000..e4bacd4
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs
@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using Mono.Addins;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Messages.Linden;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OSD = OpenMetaverse.StructuredData.OSD;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+using OpenSim.Framework.Capabilities;
+using ExtraParamType = OpenMetaverse.ExtraParamType;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class UploadObjectAssetModule : INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private Scene m_scene;
+
+        #region IRegionModuleBase Members
+
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+
+        }
+
+        public void AddRegion(Scene pScene)
+        {
+            m_scene = pScene;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        #endregion
+
+
+        #region IRegionModule Members
+
+
+
+        public void Close() { }
+
+        public string Name { get { return "UploadObjectAssetModuleModule"; } }
+
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capID = UUID.Random();
+
+//            m_log.Debug("[UPLOAD OBJECT ASSET MODULE]: /CAPS/" + capID);
+            caps.RegisterHandler("UploadObjectAsset",
+                                 new RestHTTPHandler("POST", "/CAPS/OA/" + capID + "/",
+                                                       delegate(Hashtable m_dhttpMethod)
+                                                       {
+                                                           return ProcessAdd(m_dhttpMethod, agentID, caps);
+                                                       }));
+            /*
+                   caps.RegisterHandler("NewFileAgentInventoryVariablePrice",
+
+                           new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDNewFileAngentInventoryVariablePriceReplyResponse>("POST",
+                                                                                                  "/CAPS/" + capID.ToString(),
+                                                                                                  delegate(LLSDAssetUploadRequest req)
+                                                              {
+                                                                  return NewAgentInventoryRequest(req,agentID);
+                                                              }));
+             */
+
+        }
+
+        #endregion
+
+
+        /// <summary>
+        /// Parses add request
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="AgentId"></param>
+        /// <param name="cap"></param>
+        /// <returns></returns>
+        public Hashtable ProcessAdd(Hashtable request, UUID AgentId, Caps cap)
+        {
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 400; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = "Request wasn't what was expected";
+            ScenePresence avatar;
+
+            if (!m_scene.TryGetScenePresence(AgentId, out avatar))
+                return responsedata;
+
+            OSDMap r = (OSDMap)OSDParser.Deserialize((string)request["requestbody"]);
+            UploadObjectAssetMessage message = new UploadObjectAssetMessage();
+            try
+            {
+                message.Deserialize(r);
+
+            }
+            catch (Exception ex)
+            {
+                m_log.Error("[UPLOAD OBJECT ASSET MODULE]: Error deserializing message " + ex.ToString());
+                message = null;
+            }
+
+            if (message == null)
+            {
+                responsedata["int_response_code"] = 400; //501; //410; //404;
+                responsedata["content_type"] = "text/plain";
+                responsedata["keepalive"] = false;
+                responsedata["str_response_string"] =
+                    "<llsd><map><key>error</key><string>Error parsing Object</string></map></llsd>";
+
+                return responsedata;
+            }
+
+            Vector3 pos = avatar.AbsolutePosition + (Vector3.UnitX * avatar.Rotation);
+            Quaternion rot = Quaternion.Identity;
+            Vector3 rootpos = Vector3.Zero;
+//            Quaternion rootrot = Quaternion.Identity;
+
+            SceneObjectGroup rootGroup = null;
+            SceneObjectGroup[] allparts = new SceneObjectGroup[message.Objects.Length];
+            for (int i = 0; i < message.Objects.Length; i++)
+            {
+                UploadObjectAssetMessage.Object obj = message.Objects[i];
+                PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+
+                if (i == 0)
+                {
+                    rootpos = obj.Position;
+//                    rootrot = obj.Rotation;                    
+                }
+
+                // Combine the extraparams data into it's ugly blob again....
+                //int bytelength = 0;
+                //for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++)
+                //{
+                //    bytelength += obj.ExtraParams[extparams].ExtraParamData.Length;
+                //}
+                //byte[] extraparams = new byte[bytelength];
+                //int position = 0;
+
+
+
+                //for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++)
+                //{
+                //    Buffer.BlockCopy(obj.ExtraParams[extparams].ExtraParamData, 0, extraparams, position,
+                //                     obj.ExtraParams[extparams].ExtraParamData.Length);
+                //
+                //    position += obj.ExtraParams[extparams].ExtraParamData.Length;
+               // }
+
+                //pbs.ExtraParams = extraparams;
+                for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++)
+                {
+                    UploadObjectAssetMessage.Object.ExtraParam extraParam = obj.ExtraParams[extparams];
+                    switch ((ushort)extraParam.Type)
+                    {
+                        case (ushort)ExtraParamType.Sculpt:
+                            Primitive.SculptData sculpt = new Primitive.SculptData(extraParam.ExtraParamData, 0);
+
+                            pbs.SculptEntry = true;
+
+                            pbs.SculptTexture = obj.SculptID;
+                            pbs.SculptType = (byte)sculpt.Type;
+
+                            break;
+                        case (ushort)ExtraParamType.Flexible:
+                            Primitive.FlexibleData flex = new Primitive.FlexibleData(extraParam.ExtraParamData, 0);
+                            pbs.FlexiEntry = true;
+                            pbs.FlexiDrag = flex.Drag;
+                            pbs.FlexiForceX = flex.Force.X;
+                            pbs.FlexiForceY = flex.Force.Y;
+                            pbs.FlexiForceZ = flex.Force.Z;
+                            pbs.FlexiGravity = flex.Gravity;
+                            pbs.FlexiSoftness = flex.Softness;
+                            pbs.FlexiTension = flex.Tension;
+                            pbs.FlexiWind = flex.Wind;
+                            break;
+                        case (ushort)ExtraParamType.Light:
+                            Primitive.LightData light = new Primitive.LightData(extraParam.ExtraParamData, 0);
+                            pbs.LightColorA = light.Color.A;
+                            pbs.LightColorB = light.Color.B;
+                            pbs.LightColorG = light.Color.G;
+                            pbs.LightColorR = light.Color.R;
+                            pbs.LightCutoff = light.Cutoff;
+                            pbs.LightEntry = true;
+                            pbs.LightFalloff = light.Falloff;
+                            pbs.LightIntensity = light.Intensity;
+                            pbs.LightRadius = light.Radius;
+                            break;
+                        case 0x40:
+                            pbs.ReadProjectionData(extraParam.ExtraParamData, 0);
+                            break;
+                    }
+                }
+
+                pbs.PathBegin = (ushort) obj.PathBegin;
+                pbs.PathCurve = (byte) obj.PathCurve;
+                pbs.PathEnd = (ushort) obj.PathEnd;
+                pbs.PathRadiusOffset = (sbyte) obj.RadiusOffset;
+                pbs.PathRevolutions = (byte) obj.Revolutions;
+                pbs.PathScaleX = (byte) obj.ScaleX;
+                pbs.PathScaleY = (byte) obj.ScaleY;
+                pbs.PathShearX = (byte) obj.ShearX;
+                pbs.PathShearY = (byte) obj.ShearY;
+                pbs.PathSkew = (sbyte) obj.Skew;
+                pbs.PathTaperX = (sbyte) obj.TaperX;
+                pbs.PathTaperY = (sbyte) obj.TaperY;
+                pbs.PathTwist = (sbyte) obj.Twist;
+                pbs.PathTwistBegin = (sbyte) obj.TwistBegin;
+                pbs.HollowShape = (HollowShape) obj.ProfileHollow;
+                pbs.PCode = (byte) PCode.Prim;
+                pbs.ProfileBegin = (ushort) obj.ProfileBegin;
+                pbs.ProfileCurve = (byte) obj.ProfileCurve;
+                pbs.ProfileEnd = (ushort) obj.ProfileEnd;
+                pbs.Scale = obj.Scale;
+                pbs.State = (byte) 0;
+                SceneObjectPart prim = new SceneObjectPart();
+                prim.UUID = UUID.Random();
+                prim.CreatorID = AgentId;
+                prim.OwnerID = AgentId;
+                prim.GroupID = obj.GroupID;
+                prim.LastOwnerID = prim.OwnerID;
+                prim.CreationDate = Util.UnixTimeSinceEpoch();
+                prim.Name = obj.Name;
+                prim.Description = "";
+
+                prim.PayPrice[0] = -2;
+                prim.PayPrice[1] = -2;
+                prim.PayPrice[2] = -2;
+                prim.PayPrice[3] = -2;
+                prim.PayPrice[4] = -2;
+                Primitive.TextureEntry tmp =
+                    new Primitive.TextureEntry(UUID.Parse("89556747-24cb-43ed-920b-47caed15465f"));
+
+                for (int j = 0; j < obj.Faces.Length; j++)
+                {
+                    UploadObjectAssetMessage.Object.Face face = obj.Faces[j];
+
+                    Primitive.TextureEntryFace primFace = tmp.CreateFace((uint) j);
+
+                    primFace.Bump = face.Bump;
+                    primFace.RGBA = face.Color;
+                    primFace.Fullbright = face.Fullbright;
+                    primFace.Glow = face.Glow;
+                    primFace.TextureID = face.ImageID;
+                    primFace.Rotation = face.ImageRot;
+                    primFace.MediaFlags = ((face.MediaFlags & 1) != 0);
+
+                    primFace.OffsetU = face.OffsetS;
+                    primFace.OffsetV = face.OffsetT;
+                    primFace.RepeatU = face.ScaleS;
+                    primFace.RepeatV = face.ScaleT;
+                    primFace.TexMapType = (MappingType) (face.MediaFlags & 6);
+                }
+
+                pbs.TextureEntry = tmp.GetBytes();
+                prim.Shape = pbs;
+                prim.Scale = obj.Scale;
+                
+                SceneObjectGroup grp = new SceneObjectGroup();
+
+                grp.SetRootPart(prim);
+                prim.ParentID = 0;
+                if (i == 0)
+                {
+                    rootGroup = grp;
+                   
+                }
+                grp.AttachToScene(m_scene);
+                grp.AbsolutePosition = obj.Position;
+                prim.RotationOffset = obj.Rotation;
+                
+                grp.IsAttachment = false;
+                // Required for linking
+                grp.RootPart.ClearUpdateSchedule();
+                
+                if (m_scene.Permissions.CanRezObject(1, avatar.UUID, pos))
+                {
+                    m_scene.AddSceneObject(grp);
+                    grp.AbsolutePosition = obj.Position;
+                }
+
+                allparts[i] = grp;
+            }
+
+            for (int j = 1; j < allparts.Length; j++)
+            {
+                // Required for linking
+                rootGroup.RootPart.ClearUpdateSchedule();
+                allparts[j].RootPart.ClearUpdateSchedule();
+                rootGroup.LinkToGroup(allparts[j]);
+            }
+
+            rootGroup.ScheduleGroupForFullUpdate();
+            pos
+                = m_scene.GetNewRezLocation(
+                    Vector3.Zero, rootpos, UUID.Zero, rot, (byte)1, 1, true, allparts[0].GroupScale, false);
+           
+            responsedata["int_response_code"] = 200; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = String.Format("<llsd><map><key>local_id</key>{0}</map></llsd>", ConvertUintToBytes(allparts[0].LocalId));
+
+            return responsedata;
+        }
+        
+        private string ConvertUintToBytes(uint val)
+        {
+            byte[] resultbytes = Utils.UIntToBytes(val);
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(resultbytes);
+            return String.Format("<binary encoding=\"base64\">{0}</binary>", Convert.ToBase64String(resultbytes));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
new file mode 100644
index 0000000..1dd8938
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    /// <summary>
+    /// SimulatorFeatures capability.
+    /// </summary>
+    /// <remarks>
+    /// This is required for uploading Mesh.
+    /// Since is accepts an open-ended response, we also send more information
+    /// for viewers that care to interpret it.
+    /// 
+    /// NOTE: Part of this code was adapted from the Aurora project, specifically
+    /// the normal part of the response in the capability handler.
+    /// </remarks>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class SimulatorFeaturesModule : ISharedRegionModule, ISimulatorFeaturesModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_scene;
+
+        /// <summary>
+        /// Simulator features
+        /// </summary>
+        private OSDMap m_features = new OSDMap();
+
+        private string m_MapImageServerURL = string.Empty;
+        private string m_SearchURL = string.Empty;
+
+        #region ISharedRegionModule Members
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["SimulatorFeatures"];
+            if (config != null)
+            {
+                m_MapImageServerURL = config.GetString("MapImageServerURI", string.Empty);
+                if (m_MapImageServerURL != string.Empty)
+                {
+                    m_MapImageServerURL = m_MapImageServerURL.Trim();
+                    if (!m_MapImageServerURL.EndsWith("/"))
+                        m_MapImageServerURL = m_MapImageServerURL + "/";
+                }
+    
+                m_SearchURL = config.GetString("SearchServerURI", string.Empty);
+            }
+
+            AddDefaultFeatures();
+        }
+
+        public void AddRegion(Scene s)
+        {
+            m_scene = s;
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "SimulatorFeaturesModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Add default features
+        /// </summary>
+        /// <remarks>
+        /// TODO: These should be added from other modules rather than hardcoded.
+        /// </remarks>
+        private void AddDefaultFeatures()
+        {
+            lock (m_features)
+            {
+                m_features["MeshRezEnabled"] = true;
+                m_features["MeshUploadEnabled"] = true;
+                m_features["MeshXferEnabled"] = true;
+                m_features["PhysicsMaterialsEnabled"] = true;
+    
+                OSDMap typesMap = new OSDMap();
+                typesMap["convex"] = true;
+                typesMap["none"] = true;
+                typesMap["prim"] = true;
+                m_features["PhysicsShapeTypes"] = typesMap;
+    
+                // Extra information for viewers that want to use it
+                OSDMap gridServicesMap = new OSDMap();
+                if (m_MapImageServerURL != string.Empty)
+                    gridServicesMap["map-server-url"] = m_MapImageServerURL;
+                if (m_SearchURL != string.Empty)
+                    gridServicesMap["search"] = m_SearchURL;
+                m_features["GridServices"] = gridServicesMap;
+            }
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            IRequestHandler reqHandler
+                = new RestHTTPHandler("GET", "/CAPS/" + UUID.Random(), HandleSimulatorFeaturesRequest);
+
+            caps.RegisterHandler("SimulatorFeatures", reqHandler);
+        }
+
+        public void AddFeature(string name, OSD value)
+        {
+            lock (m_features)
+                m_features[name] = value;
+        }
+
+        public bool RemoveFeature(string name)
+        {
+            lock (m_features)
+                return m_features.Remove(name);
+        }
+
+        public bool TryGetFeature(string name, out OSD value)
+        {
+            lock (m_features)
+                return m_features.TryGetValue(name, out value);
+        }
+
+        public OSDMap GetFeatures()
+        {
+            lock (m_features)
+                return new OSDMap(m_features);
+        }
+
+        private Hashtable HandleSimulatorFeaturesRequest(Hashtable mDhttpMethod)
+        {
+//            m_log.DebugFormat("[SIMULATOR FEATURES MODULE]: SimulatorFeatures request");
+
+            //Send back data
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 200; 
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+
+            lock (m_features)
+                responsedata["str_response_string"] = OSDParser.SerializeLLSDXmlString(m_features);
+
+            return responsedata;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
new file mode 100644
index 0000000..45d6071
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class UploadBakedTextureModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// For historical reasons this is fixed, but there
+        /// </summary>
+        private static readonly string m_uploadBakedTexturePath = "0010/";// This is in the LandManagementModule.
+
+        private Scene m_scene;
+        private bool m_persistBakedTextures;
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig sconfig = source.Configs["Startup"];
+            if (sconfig != null)
+                m_persistBakedTextures = sconfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
+        }
+
+        public void AddRegion(Scene s)
+        {
+            m_scene = s;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "UploadBakedTextureModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            caps.RegisterHandler(
+                "UploadBakedTexture",
+                new RestStreamHandler(
+                    "POST",
+                    "/CAPS/" + caps.CapsObjectPath + m_uploadBakedTexturePath,
+                    new UploadBakedTextureHandler(
+                        caps, m_scene.AssetService, m_persistBakedTextures).UploadBakedTexture));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
new file mode 100644
index 0000000..10f43d1
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    /// <summary>
+    /// This module implements both WebFetchInventoryDescendents and FetchInventoryDescendents2 capabilities.
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class WebFetchInvDescModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_scene;
+
+        private IInventoryService m_InventoryService;
+        private ILibraryService m_LibraryService;
+
+        private bool m_Enabled;
+
+        private string m_fetchInventoryDescendents2Url;
+        private string m_webFetchInventoryDescendentsUrl;
+
+        private WebFetchInvDescHandler m_webFetchHandler;
+
+        #region ISharedRegionModule Members
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_fetchInventoryDescendents2Url = config.GetString("Cap_FetchInventoryDescendents2", string.Empty);
+            m_webFetchInventoryDescendentsUrl = config.GetString("Cap_WebFetchInventoryDescendents", string.Empty);
+
+            if (m_fetchInventoryDescendents2Url != string.Empty || m_webFetchInventoryDescendentsUrl != string.Empty)
+            {
+                m_Enabled = true;
+            }
+        }
+
+        public void AddRegion(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene = s;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_InventoryService = m_scene.InventoryService;
+            m_LibraryService = m_scene.LibraryService;
+
+            // We'll reuse the same handler for all requests.
+            if (m_fetchInventoryDescendents2Url == "localhost" || m_webFetchInventoryDescendentsUrl == "localhost")
+                m_webFetchHandler = new WebFetchInvDescHandler(m_InventoryService, m_LibraryService);
+
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "WebFetchInvDescModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        private void RegisterCaps(UUID agentID, Caps caps)
+        {
+            if (m_webFetchInventoryDescendentsUrl != "")
+                RegisterFetchCap(agentID, caps, "WebFetchInventoryDescendents", m_webFetchInventoryDescendentsUrl);
+
+            if (m_fetchInventoryDescendents2Url != "")
+                RegisterFetchCap(agentID, caps, "FetchInventoryDescendents2", m_fetchInventoryDescendents2Url);
+        }
+
+        private void RegisterFetchCap(UUID agentID, Caps caps, string capName, string url)
+        {
+            string capUrl;
+
+            if (url == "localhost")
+            {
+                capUrl = "/CAPS/" + UUID.Random();
+
+                IRequestHandler reqHandler
+                    = new RestStreamHandler("POST", capUrl, m_webFetchHandler.FetchInventoryDescendentsRequest);
+
+                caps.RegisterHandler(capName, reqHandler);
+            }
+            else
+            {
+                capUrl = url;
+
+                caps.RegisterHandler(capName, capUrl);
+            }
+
+//            m_log.DebugFormat(
+//                "[WEB FETCH INV DESC MODULE]: Registered capability {0} at {1} in region {2} for {3}",
+//                capName, capUrl, m_scene.RegionInfo.RegionName, agentID);
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/IncomingPacket.cs b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacket.cs
index 90b3ede..90b3ede 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/IncomingPacket.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacket.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/IncomingPacketHistoryCollection.cs b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacketHistoryCollection.cs
index 1f73a1d..1f73a1d 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/IncomingPacketHistoryCollection.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacketHistoryCollection.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs b/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs
index b53a2fb..9dd6663 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs
@@ -31,7 +31,6 @@ using OpenMetaverse;
 using OpenMetaverse.Imaging;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.Framework.Scenes.Hypergrid;
 using OpenSim.Services.Interfaces;
 using log4net;
 using System.Reflection;
@@ -56,7 +55,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public IJ2KDecoder J2KDecoder;
         public IAssetService AssetService;
         public UUID AgentID;
-        public IHyperAssetService HyperAssets;
+        public IInventoryAccessModule InventoryAccessModule;
         public OpenJPEG.J2KLayerInfo[] Layers;
         public bool IsDecoded;
         public bool HasAsset;
@@ -203,6 +202,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 && Layers[0].End > FIRST_PACKET_SIZE) m_stopPacket++;
+
                         m_currentPacket = StartPacket;
                     }
                 }
@@ -376,14 +378,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             UUID assetID = UUID.Zero;
             if (asset != null)
                 assetID = asset.FullID;
-            else if ((HyperAssets != null) && (sender != HyperAssets))
+            else if ((InventoryAccessModule != null) && (sender != InventoryAccessModule))
             {
-                // Try the user's inventory, but only if it's different from the regions'
-                string userAssets = HyperAssets.GetUserAssetServer(AgentID);
-                if ((userAssets != string.Empty) && (userAssets != HyperAssets.GetSimAssetServer()))
+                // Unfortunately we need this here, there's no other way.
+                // This is due to the fact that textures opened directly from the agent's inventory
+                // don't have any distinguishing feature. As such, in order to serve those when the
+                // foreign user is visiting, we need to try again after the first fail to the local
+                // asset service.
+                string assetServerURL = string.Empty;
+                if (InventoryAccessModule.IsForeignUser(AgentID, out assetServerURL))
                 {
                     m_log.DebugFormat("[J2KIMAGE]: texture {0} not found in local asset storage. Trying user's storage.", id);
-                    AssetService.Get(userAssets + "/" + id, HyperAssets, AssetReceived);
+                    AssetService.Get(assetServerURL + "/" + id, InventoryAccessModule, AssetReceived);
                     return;
                 }
             }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index 0e4a0d0..af68de6 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -37,59 +37,22 @@ using System.Xml;
 using log4net;
 using OpenMetaverse;
 using OpenMetaverse.Packets;
+using OpenMetaverse.Messages.Linden;
 using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Framework.Client;
-using OpenSim.Framework.Communications.Cache;
 using OpenSim.Framework.Statistics;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
-using OpenSim.Region.Framework.Scenes.Hypergrid;
 using OpenSim.Services.Interfaces;
 using Timer = System.Timers.Timer;
 using AssetLandmark = OpenSim.Framework.AssetLandmark;
 using Nini.Config;
 
+using System.IO;
+
 namespace OpenSim.Region.ClientStack.LindenUDP
 {
-    #region Enums
-
-    /// <summary>
-    /// Specifies the fields that have been changed when sending a prim or
-    /// avatar update
-    /// </summary>
-    [Flags]
-    public enum PrimUpdateFlags : uint
-    {
-        None = 0,
-        AttachmentPoint = 1 << 0,
-        Material = 1 << 1,
-        ClickAction = 1 << 2,
-        Scale = 1 << 3,
-        ParentID = 1 << 4,
-        PrimFlags = 1 << 5,
-        PrimData = 1 << 6,
-        MediaURL = 1 << 7,
-        ScratchPad = 1 << 8,
-        Textures = 1 << 9,
-        TextureAnim = 1 << 10,
-        NameValue = 1 << 11,
-        Position = 1 << 12,
-        Rotation = 1 << 13,
-        Velocity = 1 << 14,
-        Acceleration = 1 << 15,
-        AngularVelocity = 1 << 16,
-        CollisionPlane = 1 << 17,
-        Text = 1 << 18,
-        Particles = 1 << 19,
-        ExtraData = 1 << 20,
-        Sound = 1 << 21,
-        Joint = 1 << 22,
-        FullUpdate = UInt32.MaxValue
-    }
-
-    #endregion Enums
-
     public delegate bool PacketMethod(IClientAPI simClient, Packet packet);
 
     /// <summary>
@@ -99,10 +62,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     public class LLClientView : IClientAPI, IClientCore, IClientIM, IClientChat, IClientIPEndpoint, IStatsCollector
     {
         /// <value>
-        /// Debug packet level.  At the moment, only 255 does anything (prints out all in and out packets).
+        /// Debug packet level.  See OpenSim.RegisterConsoleCommands() for more details.
         /// </value>
-        protected int m_debugPacketLevel = 0;
-        
+        public int DebugPacketLevel { get; set; }
+
         #region Events
 
         public event GenericMessage OnGenericMessage;
@@ -118,7 +81,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public event DeRezObject OnDeRezObject;
         public event ModifyTerrain OnModifyTerrain;
         public event Action<IClientAPI> OnRegionHandShakeReply;
-        public event GenericCall2 OnRequestWearables;
+        public event GenericCall1 OnRequestWearables;
         public event SetAppearance OnSetAppearance;
         public event AvatarNowWearing OnAvatarNowWearing;
         public event RezSingleAttachmentFromInv OnRezSingleAttachmentFromInv;
@@ -127,7 +90,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public event ObjectAttach OnObjectAttach;
         public event ObjectDeselect OnObjectDetach;
         public event ObjectDrop OnObjectDrop;
-        public event GenericCall2 OnCompleteMovementToRegion;
+        public event Action<IClientAPI, bool> OnCompleteMovementToRegion;
+        public event UpdateAgent OnPreAgentUpdate;
         public event UpdateAgent OnAgentUpdate;
         public event AgentRequestSit OnAgentRequestSit;
         public event AgentSit OnAgentSit;
@@ -183,6 +147,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public event TeleportLocationRequest OnSetStartLocationRequest;
         public event UpdateAvatarProperties OnUpdateAvatarProperties;
         public event CreateNewInventoryItem OnCreateNewInventoryItem;
+        public event LinkInventoryItem OnLinkInventoryItem;
         public event CreateInventoryFolder OnCreateNewInventoryFolder;
         public event UpdateInventoryFolder OnUpdateInventoryFolder;
         public event MoveInventoryFolder OnMoveInventoryFolder;
@@ -192,6 +157,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;
@@ -266,7 +232,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public event ScriptReset OnScriptReset;
         public event GetScriptRunning OnGetScriptRunning;
         public event SetScriptRunning OnSetScriptRunning;
-        public event UpdateVector OnAutoPilotGo;
+        public event Action<Vector3, bool, bool> OnAutoPilotGo;
         public event TerrainUnacked OnUnackedTerrain;
         public event ActivateGesture OnActivateGesture;
         public event DeactivateGesture OnDeactivateGesture;
@@ -289,7 +255,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;
@@ -320,11 +286,11 @@ 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;
-        
 
         #endregion Events
 
@@ -350,9 +316,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         private readonly IGroupsModule m_GroupsModule;
 
         private int m_cachedTextureSerial;
-        protected PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_avatarTerseUpdates;
-        private PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_primTerseUpdates;
-        private PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock> m_primFullUpdates;
+        private PriorityQueue m_entityUpdates;
+        private PriorityQueue m_entityProps;
+        private Prioritizer m_prioritizer;
+        private bool m_disableFacelights = false;
 
         /// <value>
         /// List used in construction of data blocks for an object update packet.  This is to stop us having to
@@ -365,19 +332,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// 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 m_primFullUpdate.SyncRoot lock
-        ///       
+        /// All manipulation of this set has to occur under an m_entityUpdates.SyncRoot lock
+        ///
         /// </value>
         protected HashSet<uint> m_killRecord;
-        
-//      protected HashSet<uint> m_attachmentsQueued;
-//      protected HashSet<uint> m_attachmentsSent;
-        
+
+//        protected HashSet<uint> m_attachmentsSent;
+
         private int m_moneyBalance;
+        private bool m_deliverPackets = true;
         private int m_animationSequenceNumber = 1;
         private bool m_SendLogoutPacketWhenClosing = true;
         private AgentUpdateArgs lastarg;
         private bool m_IsActive = true;
+        private bool m_IsLoggingOut = false;
 
         protected Dictionary<PacketType, PacketProcessor> m_packetHandlers = new Dictionary<PacketType, PacketProcessor>();
         protected Dictionary<string, GenericMessage> m_genericPacketHandlers = new Dictionary<string, GenericMessage>(); //PauPaw:Local Generic Message handlers
@@ -396,17 +364,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         protected uint m_agentFOVCounter;
 
         protected IAssetService m_assetService;
-        private IHyperAssetService m_hyperAssets;
         private const bool m_checkPackets = true;
 
-        private Timer m_propertiesPacketTimer;
-        private List<ObjectPropertiesPacket.ObjectDataBlock> m_propertiesBlocks = new List<ObjectPropertiesPacket.ObjectDataBlock>();
-
         #endregion Class Members
 
         #region Properties
 
         public LLUDPClient UDPClient { get { return m_udpClient; } }
+        public LLUDPServer UDPServer { get { return m_udpServer; } }
         public IPEndPoint RemoteEndPoint { get { return m_udpClient.RemoteEndPoint; } }
         public UUID SecureSessionId { get { return m_secureSessionId; } }
         public IScene Scene { get { return m_scene; } }
@@ -416,23 +381,41 @@ 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; private set; }
         public UUID ActiveGroupId { get { return m_activeGroupID; } }
         public string ActiveGroupName { get { return m_activeGroupName; } }
         public ulong ActiveGroupPowers { get { return m_activeGroupPowers; } }
         public bool IsGroupMember(UUID groupID) { return m_groupPowers.ContainsKey(groupID); }
+
+        /// <summary>
+        /// Entity update queues
+        /// </summary>
+        public PriorityQueue EntityUpdateQueue { get { return m_entityUpdates; } }
+        
         /// <summary>
         /// First name of the agent/avatar represented by the client
         /// </summary>
         public string FirstName { get { return m_firstName; } }
+
         /// <summary>
         /// Last name of the agent/avatar represented by the client
         /// </summary>
         public string LastName { get { return m_lastName; } }
+
         /// <summary>
         /// Full name of the client (first name and last name)
         /// </summary>
         public string Name { get { return FirstName + " " + LastName; } }
+
         public uint CircuitCode { get { return m_circuitCode; } }
         public int MoneyBalance { get { return m_moneyBalance; } }
         public int NextAnimationSequenceNumber { get { return m_animationSequenceNumber++; } }
@@ -441,10 +424,27 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             get { return m_IsActive; }
             set { m_IsActive = value; }
         }
+        public bool IsLoggingOut
+        {
+            get { return m_IsLoggingOut; }
+            set { m_IsLoggingOut = value; }
+        }
+
+        public bool DisableFacelights
+        {
+            get { return m_disableFacelights; }
+            set { m_disableFacelights = value; }
+        }
+
         public bool SendLogoutPacketWhenClosing { set { m_SendLogoutPacketWhenClosing = value; } }
 
         #endregion Properties
 
+//        ~LLClientView()
+//        {
+//            m_log.DebugFormat("[LLCLIENTVIEW]: Destructor called for {0}, circuit code {1}", Name, CircuitCode);
+//        }
+
         /// <summary>
         /// Constructor
         /// </summary>
@@ -459,16 +459,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             m_scene = scene;
 
-            m_avatarTerseUpdates = new PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
-            m_primTerseUpdates = new PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
-            m_primFullUpdates = new PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock>(m_scene.Entities.Count);
+            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_attachmentsQueued = new HashSet<uint>();
-//          m_attachmentsSent = new HashSet<uint>();
+//            m_attachmentsSent = new HashSet<uint>();
 
             m_assetService = m_scene.RequestModuleInterface<IAssetService>();
-            m_hyperAssets = m_scene.RequestModuleInterface<IHyperAssetService>();
             m_GroupsModule = scene.RequestModuleInterface<IGroupsModule>();
             m_imageManager = new LLImageManager(this, m_assetService, Scene.RequestModuleInterface<IJ2KDecoder>());
             m_channelVersion = Util.StringToBytes256(scene.GetSimulatorVersion());
@@ -487,17 +484,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_udpClient.OnQueueEmpty += HandleQueueEmpty;
             m_udpClient.OnPacketStats += PopulateStats;
 
-            m_propertiesPacketTimer = new Timer(100);
-            m_propertiesPacketTimer.Elapsed += ProcessObjectPropertiesPacket;
+            m_prioritizer = new Prioritizer(m_scene);
 
             RegisterLocalPacketHandlers();
         }
 
-        public void SetDebugPacketLevel(int newDebug)
-        {
-            m_debugPacketLevel = newDebug;
-        }
-
         #region Client Methods
 
 
@@ -540,7 +531,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_udpServer.Flush(m_udpClient);
 
             // Remove ourselves from the scene
-            m_scene.RemoveClient(AgentId);
+            m_scene.RemoveClient(AgentId, true);
+            SceneAgent = null;
 
             // We can't reach into other scenes and close the connection
             // We need to do this over grid communications
@@ -602,22 +594,42 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return result;
         }
 
+        /// <summary>
+        /// Add a handler for the given packet type.
+        /// </summary>
+        /// <remarks>The packet is handled on its own thread.  If packets must be handled in the order in which thye
+        /// are received then please us ethe synchronous version of this method.</remarks>
+        /// <param name="packetType"></param>
+        /// <param name="handler"></param>
+        /// <returns>true if the handler was added.  This is currently always the case.</returns>
         public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler)
         {
             return AddLocalPacketHandler(packetType, handler, true);
         }
 
-        public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler, bool async)
+        /// <summary>
+        /// Add a handler for the given packet type.
+        /// </summary>
+        /// <param name="packetType"></param>
+        /// <param name="handler"></param>
+        /// <param name="doAsync">
+        /// If true, when the packet is received it is handled on its own thread rather than on the main inward bound
+        /// packet handler thread.  This vastly increases respnosiveness but some packets need to be handled
+        /// synchronously.
+        /// </param>
+        /// <returns>true if the handler was added.  This is currently always the case.</returns>
+        public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler, bool doAsync)
         {
             bool result = false;
             lock (m_packetHandlers)
             {
                 if (!m_packetHandlers.ContainsKey(packetType))
                 {
-                    m_packetHandlers.Add(packetType, new PacketProcessor() { method = handler, Async = async });
+                    m_packetHandlers.Add(packetType, new PacketProcessor() { method = handler, Async = doAsync });
                     result = true;
                 }
             }
+
             return result;
         }
 
@@ -652,7 +664,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 if (pprocessor.Async)
                 {
                     object obj = new AsyncPacketProcess(this, pprocessor.method, packet);
-                    Util.FireAndForget(ProcessSpecificPacketAsync,obj);
+                    Util.FireAndForget(ProcessSpecificPacketAsync, obj);
                     result = true;
                 }
                 else
@@ -680,7 +692,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public void ProcessSpecificPacketAsync(object state)
         {
             AsyncPacketProcess packetObject = (AsyncPacketProcess)state;
-            packetObject.result = packetObject.Method(packetObject.ClientView, packetObject.Pack);          
+
+            try
+            {
+                packetObject.result = packetObject.Method(packetObject.ClientView, packetObject.Pack);
+            }
+            catch (Exception e)
+            {
+                // Make sure that we see any exception caused by the asynchronous operation.
+                m_log.ErrorFormat(
+                    "[LLCLIENTVIEW]: Caught exception while processing {0} for {1}, {2} {3}", 
+                    packetObject.Pack, Name, e.Message, e.StackTrace);
+            }
         }
 
         #endregion Packet Handling
@@ -689,7 +712,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public virtual void Start()
         {
-            m_scene.AddNewClient(this);
+            SceneAgent = m_scene.AddNewClient(this, PresenceType.User);
 
             RefreshGroupMembership();
         }
@@ -748,7 +771,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             handshake.RegionInfo3.CPURatio = 1;
 
             handshake.RegionInfo3.ColoName = Utils.EmptyBytes;
-            handshake.RegionInfo3.ProductName = Utils.EmptyBytes;
+            handshake.RegionInfo3.ProductName = Util.StringToBytes256(regionInfo.RegionType);
             handshake.RegionInfo3.ProductSKU = Utils.EmptyBytes;
 
             OutPacket(handshake, ThrottleOutPacketType.Task);
@@ -793,7 +816,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             reply.ChatData.OwnerID = fromAgentID;
             reply.ChatData.SourceID = fromAgentID;
 
-            OutPacket(reply, ThrottleOutPacketType.Task);
+            OutPacket(reply, ThrottleOutPacketType.Unknown);
         }
 
         /// <summary>
@@ -855,6 +878,21 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
 
+        public void SendGenericMessage(string method, List<string> message)
+        {
+            GenericMessagePacket gmp = new GenericMessagePacket();
+            gmp.MethodData.Method = Util.StringToBytes256(method);
+            gmp.ParamList = new GenericMessagePacket.ParamListBlock[message.Count];
+            int i = 0;
+            foreach (string val in message)
+            {
+                gmp.ParamList[i] = new GenericMessagePacket.ParamListBlock();
+                gmp.ParamList[i++].Parameter = Util.StringToBytes256(val);
+            }
+
+            OutPacket(gmp, ThrottleOutPacketType.Task);
+        }
+
         public void SendGenericMessage(string method, List<byte[]> message)
         {
             GenericMessagePacket gmp = new GenericMessagePacket();
@@ -866,6 +904,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 gmp.ParamList[i] = new GenericMessagePacket.ParamListBlock();
                 gmp.ParamList[i++].Parameter = val;
             }
+
             OutPacket(gmp, ThrottleOutPacketType.Task);
         }
 
@@ -875,7 +914,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             foreach (GroupActiveProposals Proposal in Proposals)
             {
                 GroupActiveProposalItemReplyPacket GAPIRP = new GroupActiveProposalItemReplyPacket();
-                
+
                 GAPIRP.AgentData.AgentID = AgentId;
                 GAPIRP.AgentData.GroupID = groupID;
                 GAPIRP.TransactionData.TransactionID = transactionID;
@@ -899,7 +938,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (Proposals.Length == 0)
             {
                 GroupActiveProposalItemReplyPacket GAPIRP = new GroupActiveProposalItemReplyPacket();
-                
+
                 GAPIRP.AgentData.AgentID = AgentId;
                 GAPIRP.AgentData.GroupID = groupID;
                 GAPIRP.TransactionData.TransactionID = transactionID;
@@ -954,7 +993,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (Votes.Length == 0)
             {
                 GroupVoteHistoryItemReplyPacket GVHIRP = new GroupVoteHistoryItemReplyPacket();
-                
+
                 GVHIRP.AgentData.AgentID = AgentId;
                 GVHIRP.AgentData.GroupID = groupID;
                 GVHIRP.TransactionData.TransactionID = transactionID;
@@ -978,7 +1017,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 OutPacket(GVHIRP, ThrottleOutPacketType.Task);
             }
         }
-        
+
         public void SendGroupAccountingDetails(IClientAPI sender,UUID groupID, UUID transactionID, UUID sessionID, int amt)
         {
             GroupAccountDetailsReplyPacket GADRP = new GroupAccountDetailsReplyPacket();
@@ -997,13 +1036,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             GADRP.HistoryData[0] = History;
             OutPacket(GADRP, ThrottleOutPacketType.Task);
         }
-        
+
         public void SendGroupAccountingSummary(IClientAPI sender,UUID groupID, uint moneyAmt, int totalTier, int usedTier)
         {
             GroupAccountSummaryReplyPacket GASRP =
                     (GroupAccountSummaryReplyPacket)PacketPool.Instance.GetPacket(
                     PacketType.GroupAccountSummaryReply);
-            
+
             GASRP.AgentData = new GroupAccountSummaryReplyPacket.AgentDataBlock();
             GASRP.AgentData.AgentID = sender.AgentId;
             GASRP.AgentData.GroupID = groupID;
@@ -1030,13 +1069,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             GASRP.MoneyData.LightTaxEstimate = 0;
             OutPacket(GASRP, ThrottleOutPacketType.Task);
         }
-        
+
         public void SendGroupTransactionsSummaryDetails(IClientAPI sender,UUID groupID, UUID transactionID, UUID sessionID, int amt)
         {
             GroupAccountTransactionsReplyPacket GATRP =
                     (GroupAccountTransactionsReplyPacket)PacketPool.Instance.GetPacket(
                     PacketType.GroupAccountTransactionsReply);
-            
+
             GATRP.AgentData = new GroupAccountTransactionsReplyPacket.AgentDataBlock();
             GATRP.AgentData.AgentID = sender.AgentId;
             GATRP.AgentData.GroupID = groupID;
@@ -1354,7 +1393,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendMapBlock(List<MapBlockData> mapBlocks, uint flag)
         {
-
             MapBlockData[] mapBlocks2 = mapBlocks.ToArray();
 
             int maxsend = 10;
@@ -1432,16 +1470,27 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>
         ///
         /// </summary>
-        public void SendTeleportLocationStart()
+        public void SendTeleportStart(uint flags)
         {
-            //TeleportStartPacket tpStart = (TeleportStartPacket)PacketPool.Instance.GetPacket(PacketType.TeleportStart);
-            TeleportStartPacket tpStart = new TeleportStartPacket();
-            tpStart.Info.TeleportFlags = 16; // Teleport via location
+            TeleportStartPacket tpStart = (TeleportStartPacket)PacketPool.Instance.GetPacket(PacketType.TeleportStart);
+            //TeleportStartPacket tpStart = new TeleportStartPacket();
+            tpStart.Info.TeleportFlags = flags; //16; // Teleport via location
 
             // Hack to get this out immediately and skip throttles
             OutPacket(tpStart, ThrottleOutPacketType.Unknown);
         }
 
+        public void SendTeleportProgress(uint flags, string message)
+        {
+            TeleportProgressPacket tpProgress = (TeleportProgressPacket)PacketPool.Instance.GetPacket(PacketType.TeleportProgress);
+            tpProgress.AgentData.AgentID = this.AgentId;
+            tpProgress.Info.TeleportFlags = flags;
+            tpProgress.Info.Message = Util.StringToBytes256(message);
+
+            // Hack to get this out immediately and skip throttles
+            OutPacket(tpProgress, ThrottleOutPacketType.Unknown);
+        }
+
         public void SendMoneyBalance(UUID transaction, bool success, byte[] description, int balance)
         {
             MoneyBalanceReplyPacket money = (MoneyBalanceReplyPacket)PacketPool.Instance.GetPacket(PacketType.MoneyBalanceReply);
@@ -1450,6 +1499,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             money.MoneyData.TransactionSuccess = success;
             money.MoneyData.Description = description;
             money.MoneyData.MoneyBalance = balance;
+            money.TransactionInfo.ItemDescription = Util.StringToBytes256("NONE");
             OutPacket(money, ThrottleOutPacketType.Task);
         }
 
@@ -1491,30 +1541,50 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(pc, ThrottleOutPacketType.Unknown);
         }
 
-        public void SendKillObject(ulong regionHandle, uint localID)
+        public void SendKillObject(ulong regionHandle, List<uint> localIDs)
         {
 //            m_log.DebugFormat("[CLIENT]: Sending KillObjectPacket to {0} for {1} in {2}", Name, localID, regionHandle);
-            
+
             KillObjectPacket kill = (KillObjectPacket)PacketPool.Instance.GetPacket(PacketType.KillObject);
             // TODO: don't create new blocks if recycling an old packet
-            kill.ObjectData = new KillObjectPacket.ObjectDataBlock[1];
-            kill.ObjectData[0] = new KillObjectPacket.ObjectDataBlock();
-            kill.ObjectData[0].ID = localID;
+            kill.ObjectData = new KillObjectPacket.ObjectDataBlock[localIDs.Count];
+            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;
 
-            lock (m_primFullUpdates.SyncRoot)
+            if (localIDs.Count == 1 && m_scene.GetScenePresence(localIDs[0]) != null)
             {
-                m_killRecord.Add(localID);
                 OutPacket(kill, ThrottleOutPacketType.State);
             }
+            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)
+                {
+                    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.
+                    OutPacket(kill, ThrottleOutPacketType.Task);
+                }
+            }
         }
 
         /// <summary>
         /// Send information about the items contained in a folder to the client.
-        ///
-        /// XXX This method needs some refactoring loving
         /// </summary>
+        /// <remarks>
+        /// XXX This method needs some refactoring loving
+        /// </remarks>
         /// <param name="ownerID">The owner of the folder</param>
         /// <param name="folderID">The id of the folder</param>
         /// <param name="items">The items contained in the folder identified by folderID</param>
@@ -1578,14 +1648,19 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     currentPacket.ItemData[itemsSent % MAX_ITEMS_PER_PACKET] = CreateItemDataBlock(items[itemsSent++]);
                 else
                 {
+//                    m_log.DebugFormat(
+//                        "[LLCLIENTVIEW]: Sending inventory folder details packet to {0} for folder {1}", Name, folderID);
                     OutPacket(currentPacket, ThrottleOutPacketType.Asset, false);
                     currentPacket = null;
                 }
-
             }
 
             if (currentPacket != null)
+            {
+//                m_log.DebugFormat(
+//                    "[LLCLIENTVIEW]: Sending inventory folder details packet to {0} for folder {1}", Name, folderID);
                 OutPacket(currentPacket, ThrottleOutPacketType.Asset, false);
+            }
         }
 
         private InventoryDescendentsPacket.FolderDataBlock CreateFolderDataBlock(InventoryFolderBase folder)
@@ -1898,8 +1973,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 SendBulkUpdateInventoryItem((InventoryItemBase)node);
             else if (node is InventoryFolderBase)
                 SendBulkUpdateInventoryFolder((InventoryFolderBase)node);
+            else if (node != null)
+                m_log.ErrorFormat("[CLIENT]: {0} sent unknown inventory node named {1}", Name, node.Name);
             else
-                m_log.ErrorFormat("[CLIENT]: Client for {0} sent unknown inventory node named {1}", Name, node.Name);
+                m_log.ErrorFormat("[CLIENT]: {0} sent null inventory node", Name);
         }
 
         protected void SendBulkUpdateInventoryItem(InventoryItemBase item)
@@ -2048,6 +2125,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(sendXfer, ThrottleOutPacketType.Asset);
         }
 
+        public void SendAbortXferPacket(ulong xferID)
+        {
+            AbortXferPacket xferItem = (AbortXferPacket)PacketPool.Instance.GetPacket(PacketType.AbortXfer);
+            xferItem.XferID.ID = xferID;
+            OutPacket(xferItem, ThrottleOutPacketType.Asset);
+        }
+
         public void SendEconomyData(float EnergyEfficiency, int ObjectCapacity, int ObjectCount, int PriceEnergyUnit,
                                     int PriceGroupCreate, int PriceObjectClaim, float PriceObjectRent, float PriceObjectScaleFactor,
                                     int PriceParcelClaim, float PriceParcelClaimFactor, int PriceParcelRent, int PricePublicObjectDecay,
@@ -2167,7 +2251,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(loadURL, ThrottleOutPacketType.Task);
         }
 
-        public void SendDialog(string objectname, UUID objectID, string ownerFirstName, string ownerLastName, string msg, UUID textureID, int ch, string[] buttonlabels)
+        public void SendDialog(
+            string objectname, UUID objectID, UUID ownerID, string ownerFirstName, string ownerLastName, string msg,
+            UUID textureID, int ch, string[] buttonlabels)
         {
             ScriptDialogPacket dialog = (ScriptDialogPacket)PacketPool.Instance.GetPacket(PacketType.ScriptDialog);
             dialog.Data.ObjectID = objectID;
@@ -2185,6 +2271,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 buttons[i].ButtonLabel = Util.StringToBytes256(buttonlabels[i]);
             }
             dialog.Buttons = buttons;
+
+            dialog.OwnerData = new ScriptDialogPacket.OwnerDataBlock[1];
+            dialog.OwnerData[0] = new ScriptDialogPacket.OwnerDataBlock();
+            dialog.OwnerData[0].OwnerID = ownerID;
+
             OutPacket(dialog, ThrottleOutPacketType.Task);
         }
 
@@ -2213,6 +2304,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);
@@ -2247,8 +2347,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 OrbitalPosition = (OrbitalPosition - m_sunPainDaHalfOrbitalCutoff) * 0.6666666667f + m_sunPainDaHalfOrbitalCutoff;
             }
 
-
-
             SimulatorViewerTimeMessagePacket viewertime = (SimulatorViewerTimeMessagePacket)PacketPool.Instance.GetPacket(PacketType.SimulatorViewerTimeMessage);
             viewertime.TimeInfo.SunDirection = Position;
             viewertime.TimeInfo.SunAngVelocity = Velocity;
@@ -2329,7 +2427,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             packet.Effect = effectBlocks;
 
-            OutPacket(packet, ThrottleOutPacketType.State);
+            // OutPacket(packet, ThrottleOutPacketType.State);
+            OutPacket(packet, ThrottleOutPacketType.Task);
         }
 
         public void SendAvatarProperties(UUID avatarID, string aboutText, string bornOn, Byte[] charterMember,
@@ -2558,6 +2657,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendAsset(AssetRequestToClient req)
         {
+            if (req.AssetInf.Data == null)
+            {
+                m_log.ErrorFormat("Cannot send asset {0} ({1}), asset data is null",
+                    req.AssetInf.ID, req.AssetInf.Metadata.ContentType);
+                return;
+            }
+
             //m_log.Debug("sending asset " + req.RequestAssetID);
             TransferInfoPacket Transfer = new TransferInfoPacket();
             Transfer.TransferInfo.ChannelType = 2;
@@ -2645,6 +2751,10 @@ 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;
@@ -2656,7 +2766,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             // Bit 0: Mature, bit 7: on sale, other bits: no idea
             reply.Data.Flags = (byte)(
-                ((land.Flags & (uint)ParcelFlags.MaturePublish) != 0 ? (1 << 0) : 0) +
+                (info.AccessLevel > 13 ? (1 << 0) : 0) +
                 ((land.Flags & (uint)ParcelFlags.ForSale) != 0 ? (1 << 7) : 0));
 
             Vector3 pos = land.UserLocation;
@@ -2664,12 +2774,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 pos = (land.AABBMax + land.AABBMin) * 0.5f;
             }
-            reply.Data.GlobalX = info.RegionLocX * Constants.RegionSize + x;
-            reply.Data.GlobalY = info.RegionLocY * Constants.RegionSize + y;
+            reply.Data.GlobalX = info.RegionLocX + x;
+            reply.Data.GlobalY = info.RegionLocY + y;
             reply.Data.GlobalZ = pos.Z;
             reply.Data.SimName = Utils.StringToBytes(info.RegionName);
             reply.Data.SnapshotID = land.SnapshotID;
-            reply.Data.Dwell = land.Dwell;
+            reply.Data.Dwell = dwell;
             reply.Data.SalePrice = land.SalePrice;
             reply.Data.AuctionID = (int)land.AuctionID;
 
@@ -2697,32 +2807,58 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             packet.QueryData = new DirPlacesReplyPacket.QueryDataBlock[1];
             packet.QueryData[0] = new DirPlacesReplyPacket.QueryDataBlock();
 
-            packet.QueryReplies =
-                    new DirPlacesReplyPacket.QueryRepliesBlock[data.Length];
-
-            packet.StatusData = new DirPlacesReplyPacket.StatusDataBlock[
-                    data.Length];
-
             packet.AgentData.AgentID = AgentId;
 
             packet.QueryData[0].QueryID = queryID;
 
-            int i = 0;
+            DirPlacesReplyPacket.QueryRepliesBlock[] replies =
+                    new DirPlacesReplyPacket.QueryRepliesBlock[0];
+            DirPlacesReplyPacket.StatusDataBlock[] status =
+                    new DirPlacesReplyPacket.StatusDataBlock[0];
+
+            packet.QueryReplies = replies;
+            packet.StatusData = status;
+
             foreach (DirPlacesReplyData d in data)
             {
-                packet.QueryReplies[i] =
-                        new DirPlacesReplyPacket.QueryRepliesBlock();
-                packet.StatusData[i] = new DirPlacesReplyPacket.StatusDataBlock();
-                packet.QueryReplies[i].ParcelID = d.parcelID;
-                packet.QueryReplies[i].Name = Utils.StringToBytes(d.name);
-                packet.QueryReplies[i].ForSale = d.forSale;
-                packet.QueryReplies[i].Auction = d.auction;
-                packet.QueryReplies[i].Dwell = d.dwell;
-                packet.StatusData[i].Status = d.Status;
-                i++;
+                int idx = replies.Length;
+                Array.Resize(ref replies, idx + 1);
+                Array.Resize(ref status, idx + 1);
+
+                replies[idx] = new DirPlacesReplyPacket.QueryRepliesBlock();
+                status[idx] = new DirPlacesReplyPacket.StatusDataBlock();
+                replies[idx].ParcelID = d.parcelID;
+                replies[idx].Name = Utils.StringToBytes(d.name);
+                replies[idx].ForSale = d.forSale;
+                replies[idx].Auction = d.auction;
+                replies[idx].Dwell = d.dwell;
+                status[idx].Status = d.Status;
+
+                packet.QueryReplies = replies;
+                packet.StatusData = status;
+
+                if (packet.Length >= 1000)
+                {
+                    OutPacket(packet, ThrottleOutPacketType.Task);
+
+                    packet = (DirPlacesReplyPacket)PacketPool.Instance.GetPacket(PacketType.DirPlacesReply);
+
+                    packet.AgentData = new DirPlacesReplyPacket.AgentDataBlock();
+
+                    packet.QueryData = new DirPlacesReplyPacket.QueryDataBlock[1];
+                    packet.QueryData[0] = new DirPlacesReplyPacket.QueryDataBlock();
+
+                    packet.AgentData.AgentID = AgentId;
+
+                    packet.QueryData[0].QueryID = queryID;
+
+                    replies = new DirPlacesReplyPacket.QueryRepliesBlock[0];
+                    status = new DirPlacesReplyPacket.StatusDataBlock[0];
+                }
             }
 
-            OutPacket(packet, ThrottleOutPacketType.Task);
+            if (replies.Length > 0 || data.Length == 0)
+                OutPacket(packet, ThrottleOutPacketType.Task);
         }
 
         public void SendDirPeopleReply(UUID queryID, DirPeopleReplyData[] data)
@@ -3015,7 +3151,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
              {
                  OSDMap GroupDataMap = new OSDMap(6);
                  OSDMap NewGroupDataMap = new OSDMap(1);
-                 GroupDataMap.Add("GroupPowers", OSD.FromBinary(m.GroupPowers));
+                 GroupDataMap.Add("GroupPowers", OSD.FromULong(m.GroupPowers));
                  GroupDataMap.Add("AcceptNotices", OSD.FromBoolean(m.AcceptNotices));
                  GroupDataMap.Add("GroupTitle", OSD.FromString(m.GroupTitle));
                  GroupDataMap.Add("GroupID", OSD.FromUUID(m.GroupID));
@@ -3323,20 +3459,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             aw.AgentData.SerialNum = (uint)serial;
             aw.AgentData.SessionID = m_sessionId;
 
+            int count = 0;
+            for (int i = 0; i < wearables.Length; i++)
+                count += wearables[i].Count;
+
             // TODO: don't create new blocks if recycling an old packet
-            aw.WearableData = new AgentWearablesUpdatePacket.WearableDataBlock[13];
+            aw.WearableData = new AgentWearablesUpdatePacket.WearableDataBlock[count];
             AgentWearablesUpdatePacket.WearableDataBlock awb;
+            int idx = 0;
             for (int i = 0; i < wearables.Length; i++)
             {
-                awb = new AgentWearablesUpdatePacket.WearableDataBlock();
-                awb.WearableType = (byte)i;
-                awb.AssetID = wearables[i].AssetID;
-                awb.ItemID = wearables[i].ItemID;
-                aw.WearableData[i] = awb;
+                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);
@@ -3359,6 +3504,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             avp.Sender.IsTrial = false;
             avp.Sender.ID = agentID;
+            //m_log.DebugFormat("[CLIENT]: Sending appearance for {0} to {1}", agentID.ToString(), AgentId.ToString());
             OutPacket(avp, ThrottleOutPacketType.Task);
         }
 
@@ -3381,9 +3527,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 ani.AnimationList[i].AnimSequenceID = seqs[i];
 
                 ani.AnimationSourceList[i] = new AvatarAnimationPacket.AnimationSourceListBlock();
-                ani.AnimationSourceList[i].ObjectID = objectIDs[i];
-                if (objectIDs[i] == UUID.Zero)
-                    ani.AnimationSourceList[i].ObjectID = sourceAgentId;
+                if (objectIDs[i].Equals(sourceAgentId))
+                    ani.AnimationSourceList[i].ObjectID = UUID.Zero;
+                else
+                    ani.AnimationSourceList[i].ObjectID = objectIDs[i];
             }
             ani.Header.Reliable = false;
             OutPacket(ani, ThrottleOutPacketType.Task);
@@ -3396,70 +3543,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>
         /// Send an ObjectUpdate packet with information about an avatar
         /// </summary>
-        public void SendAvatarData(SendAvatarData data)
+        public void SendAvatarDataImmediate(ISceneEntity avatar)
         {
+            ScenePresence presence = avatar as ScenePresence;
+            if (presence == null)
+                return;
+
             ObjectUpdatePacket objupdate = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);
             objupdate.Header.Zerocoded = true;
 
-            objupdate.RegionData.RegionHandle = data.RegionHandle;
+            objupdate.RegionData.RegionHandle = presence.RegionHandle;
             objupdate.RegionData.TimeDilation = ushort.MaxValue;
 
             objupdate.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
-            objupdate.ObjectData[0] = CreateAvatarUpdateBlock(data);
-            OutPacket(objupdate, ThrottleOutPacketType.Task);
-            
-            // We need to record the avatar local id since the root prim of an attachment points to this.
-//          m_attachmentsSent.Add(data.AvatarLocalID);
-        }
-
-        /// <summary>
-        /// Send a terse positional/rotation/velocity update about an avatar
-        /// to the client.  This avatar can be that of the client itself.
-        /// </summary>
-        public virtual void SendAvatarTerseUpdate(SendAvatarTerseData data)
-        {
-            if (data.Priority == double.NaN)
-            {
-                m_log.Error("[LLClientView] SendAvatarTerseUpdate received a NaN priority, dropping update");
-                return;
-            }
-
-            Quaternion rotation = data.Rotation;
-            if (rotation.W == 0.0f && rotation.X == 0.0f && rotation.Y == 0.0f && rotation.Z == 0.0f)
-                rotation = Quaternion.Identity;
-
-            ImprovedTerseObjectUpdatePacket.ObjectDataBlock terseBlock = CreateImprovedTerseBlock(data);
-
-            lock (m_avatarTerseUpdates.SyncRoot)
-                m_avatarTerseUpdates.Enqueue(data.Priority, terseBlock, data.LocalID);
-
-            // If we received an update about our own avatar, process the avatar update priority queue immediately
-            if (data.AgentID == m_agentId)
-                ProcessAvatarTerseUpdates();
-        }
-
-        protected void ProcessAvatarTerseUpdates()
-        {
-            ImprovedTerseObjectUpdatePacket terse = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate);
-            terse.Header.Reliable = false;
-            terse.Header.Zerocoded = true;
-
-            //terse.RegionData = new ImprovedTerseObjectUpdatePacket.RegionDataBlock();
-            terse.RegionData.RegionHandle = Scene.RegionInfo.RegionHandle;
-            terse.RegionData.TimeDilation = (ushort)(Scene.TimeDilation * ushort.MaxValue);
-
-            lock (m_avatarTerseUpdates.SyncRoot)
-            {
-                int count = Math.Min(m_avatarTerseUpdates.Count, m_udpServer.AvatarTerseUpdatesPerPacket);
-                if (count == 0)
-                    return;
+            objupdate.ObjectData[0] = CreateAvatarUpdateBlock(presence);
 
-                terse.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[count];
-                for (int i = 0; i < count; i++)
-                    terse.ObjectData[i] = m_avatarTerseUpdates.Dequeue();
-            }
+            OutPacket(objupdate, ThrottleOutPacketType.Task);
 
-            OutPacket(terse, ThrottleOutPacketType.State);
+            // We need to record the avatar local id since the root prim of an attachment points to this.
+//            m_attachmentsSent.Add(avatar.LocalId);
         }
 
         public void SendCoarseLocationUpdate(List<UUID> users, List<Vector3> CoarseLocations)
@@ -3469,7 +3571,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             CoarseLocationUpdatePacket loc = (CoarseLocationUpdatePacket)PacketPool.Instance.GetPacket(PacketType.CoarseLocationUpdate);
             loc.Header.Reliable = false;
 
-            // Each packet can only hold around 62 avatar positions and the client clears the mini-map each time
+            // Each packet can only hold around 60 avatar positions and the client clears the mini-map each time
             // a CoarseLocationUpdate packet is received. Oh well.
             int total = Math.Min(CoarseLocations.Count, 60);
 
@@ -3506,249 +3608,374 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         #region Primitive Packet/Data Sending Methods
 
-        public void SendPrimitiveToClient(SendPrimitiveData data)
+        
+        /// <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)
         {
-//            string text = data.text;
-//            if (text.IndexOf("\n") >= 0)
-//                text = text.Remove(text.IndexOf("\n"));
-//            m_log.DebugFormat(
-//                "[CLIENT]: Queueing send full info about prim {0}, attachment {1}, text {2} to client {3}", 
-//                data.localID, data.attachment, text, Name);
-            
-            if (data.priority == double.NaN)
+            if (entity is SceneObjectPart)
             {
-                m_log.Error("[LLClientView] SendPrimitiveToClient received a NaN priority, dropping update");
-                return;
+                SceneObjectPart e = (SceneObjectPart)entity;
+                SceneObjectGroup g = e.ParentGroup;
+                if (g.RootPart.Shape.State > 30) // HUD
+                    if (g.OwnerID != AgentId)
+                        return; // Don't send updates for other people's HUDs
             }
 
-            Quaternion rotation = data.rotation;
-            if (rotation.W == 0.0f && rotation.X == 0.0f && rotation.Y == 0.0f && rotation.Z == 0.0f)
-                rotation = Quaternion.Identity;
+            uint priority = m_prioritizer.GetUpdatePriority(this, entity);
 
-            if (data.AttachPoint > 30 && data.ownerID != AgentId) // Someone else's HUD
-                return;
-            if (data.primShape.State != 0 && data.parentID == 0 && data.primShape.PCode == 9)
-                return;
+            lock (m_entityUpdates.SyncRoot)
+                m_entityUpdates.Enqueue(priority, new EntityUpdate(entity, updateFlags, m_scene.TimeDilation));
+        }
 
-            ObjectUpdatePacket.ObjectDataBlock objectData = CreatePrimUpdateBlock(data);
-            
-//          if (data.attachment)
-//              m_attachmentsQueued.Add(data.localID);
-
-            lock (m_primFullUpdates.SyncRoot)
-                m_primFullUpdates.Enqueue(data.priority, objectData, data.localID);
-        }
-
-        void ProcessPrimFullUpdates()
-        {
-            ObjectUpdatePacket outPacket = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);
-            outPacket.Header.Zerocoded = true;
-
-            outPacket.RegionData.RegionHandle = Scene.RegionInfo.RegionHandle;
-            outPacket.RegionData.TimeDilation = (ushort)(Scene.TimeDilation * ushort.MaxValue);
-
-            lock (m_primFullUpdates.SyncRoot)
-            {
-                int count = Math.Min(m_primFullUpdates.Count, m_udpServer.PrimFullUpdatesPerPacket);
-                if (count == 0)
-                    return;
-
-                m_fullUpdateDataBlocksBuilder.Clear();
-                                
-                for (int i = 0; i < count; i++)
-                {
-                    ObjectUpdatePacket.ObjectDataBlock block = m_primFullUpdates.Dequeue();
-
-                    if (!m_killRecord.Contains(block.ID))
-                    {                                                
-//                      if (m_attachmentsQueued.Contains(block.ID))
-//                      {
-//                          string text = Util.FieldToString(block.Text);
-//                          if (text.IndexOf("\n") >= 0)
-//                              text = text.Remove(text.IndexOf("\n"));
-//                            
-//                          if (m_attachmentsSent.Contains(block.ParentID))
-//                          {
-//                              m_log.DebugFormat(
-//                                  "[CLIENT]: Sending full info about attached prim {0} text {1}",
-//                                  block.ID, text);
-//                                
-//                                m_fullUpdateDataBlocksBuilder.Add(block);
-//                                
-//                                m_attachmentsSent.Add(block.ID);
-//                            }
-//                            else
-//                            {
-//                                m_log.DebugFormat(
-//                                    "[CLIENT]: Requeueing full update of prim {0} text {1} since we haven't sent its parent {2} yet", 
-//                                    block.ID, text, block.ParentID);
-//                                
-//                                lock (m_primFullUpdates.SyncRoot)
-//                                    m_primFullUpdates.Enqueue(double.MaxValue, block, block.ID);                                
-//                            }
-//                        }
-//                        else
-//                        {
-                        m_fullUpdateDataBlocksBuilder.Add(block);
-//                        }
-                    }
-//                    else
-//                    {
-//                        m_log.WarnFormat(
-//                            "[CLIENT]: Preventing full update for {0} after kill to {1}", block.ID, Name);                        
-//                    }
-                }
+        /// <summary>
+        /// Requeue an EntityUpdate when it was not acknowledged by the client. 
+        /// We will update the priority and put it in the correct queue, merging update flags 
+        /// with any other updates that may be queued for the same entity. 
+        /// The original update time is used for the merged update.
+        /// </summary>
+        private void ResendPrimUpdate(EntityUpdate update)
+        {
+            // If the update exists in priority queue, it will be updated.
+            // If it does not exist then it will be added with the current (rather than its original) priority
+            uint priority = m_prioritizer.GetUpdatePriority(this, update.Entity);
 
-                outPacket.ObjectData = m_fullUpdateDataBlocksBuilder.ToArray();
-                
-                OutPacket(outPacket, ThrottleOutPacketType.State);
-            }            
+            lock (m_entityUpdates.SyncRoot)
+                m_entityUpdates.Enqueue(priority, update);
         }
 
-        public void SendPrimTerseUpdate(SendPrimitiveTerseData data)
+        /// <summary>
+        /// Requeue a list of EntityUpdates when they were not acknowledged by the client. 
+        /// We will update the priority and put it in the correct queue, merging update flags 
+        /// with any other updates that may be queued for the same entity. 
+        /// The original update time is used for the merged update.
+        /// </summary>
+        private void ResendPrimUpdates(List<EntityUpdate> updates, OutgoingPacket oPacket)
         {
-            if (data.Priority == double.NaN)
-            {
-                m_log.Error("[LLClientView] SendPrimTerseUpdate received a NaN priority, dropping update");
-                return;
-            }
+            // m_log.WarnFormat("[CLIENT] resending prim updates {0}, packet sequence number {1}", updates[0].UpdateTime, oPacket.SequenceNumber);
 
-            Quaternion rotation = data.Rotation;
-            if (rotation.W == 0.0f && rotation.X == 0.0f && rotation.Y == 0.0f && rotation.Z == 0.0f)
-                rotation = Quaternion.Identity;
+            // Remove the update packet from the list of packets waiting for acknowledgement
+            // because we are requeuing the list of updates. They will be resent in new packets
+            // with the most recent state and priority.
+            m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);
 
-            if (data.AttachPoint > 30 && data.OwnerID != AgentId) // Someone else's HUD
-                return;
-
-            ImprovedTerseObjectUpdatePacket.ObjectDataBlock objectData = CreateImprovedTerseBlock(data);
+            // 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);
 
-            lock (m_primTerseUpdates.SyncRoot)
-                m_primTerseUpdates.Enqueue(data.Priority, objectData, data.LocalID);
+            foreach (EntityUpdate update in updates)
+                ResendPrimUpdate(update);
         }
 
-        void ProcessPrimTerseUpdates()
+        private void ProcessEntityUpdates(int maxUpdates)
         {
-            ImprovedTerseObjectUpdatePacket outPacket = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate);
-            outPacket.Header.Reliable = false;
-            outPacket.Header.Zerocoded = true;
+            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>>();
 
-            outPacket.RegionData.RegionHandle = Scene.RegionInfo.RegionHandle;
-            outPacket.RegionData.TimeDilation = (ushort)(Scene.TimeDilation * ushort.MaxValue);
+            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>>();
 
-            lock (m_primTerseUpdates.SyncRoot)
+            // Check to see if this is a flush
+            if (maxUpdates <= 0)
             {
-                int count = Math.Min(m_primTerseUpdates.Count, m_udpServer.PrimTerseUpdatesPerPacket);
-                if (count == 0)
-                    return;
-
-                outPacket.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[count];
-                for (int i = 0; i < count; i++)
-                    outPacket.ObjectData[i] = m_primTerseUpdates.Dequeue();
+                maxUpdates = Int32.MaxValue;
             }
 
-            OutPacket(outPacket, ThrottleOutPacketType.State);
-        }
+            int updatesThisCall = 0;
 
-        public void ReprioritizeUpdates(StateUpdateTypes type, UpdatePriorityHandler handler)
-        {
-            PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>.UpdatePriorityHandler terse_update_priority_handler =
-                delegate(ref double priority, uint local_id)
+            // 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.                        
+            float avgTimeDilation = 1.0f;
+            IEntityUpdate iupdate;
+            Int32 timeinqueue; // this is just debugging code & can be dropped later
+                
+            while (updatesThisCall < maxUpdates)
+            {
+                lock (m_entityUpdates.SyncRoot)
+                    if (!m_entityUpdates.TryDequeue(out iupdate, out timeinqueue))
+                        break;
+
+                EntityUpdate update = (EntityUpdate)iupdate;
+                    
+                avgTimeDilation += update.TimeDilation;
+                avgTimeDilation *= 0.5f;
+
+                if (update.Entity is SceneObjectPart)
+                {
+                    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.
+                    lock (m_killRecord)
+                    {
+                        if (m_killRecord.Contains(part.LocalId))
+                            continue;
+                        if (m_killRecord.Contains(part.ParentGroup.RootPart.LocalId))
+                            continue;
+                    }
+
+                    if (part.ParentGroup.IsDeleted)
+                        continue;
+
+                    if (part.ParentGroup.IsAttachment)
+                    {   // Someone else's HUD, why are we getting these?
+                        if (part.ParentGroup.OwnerID != AgentId &&
+                            part.ParentGroup.RootPart.Shape.State >= 30)
+                            continue;
+                        ScenePresence sp;
+                        // Owner is not in the sim, don't update it to
+                        // anyone
+                        if (!m_scene.TryGetScenePresence(part.OwnerID, out sp))
+                            continue;
+
+                        List<SceneObjectGroup> atts = sp.GetAttachments();
+                        bool found = false;
+                        foreach (SceneObjectGroup att in atts)
+                        {
+                            if (att == part.ParentGroup)
+                            {
+                                found = true;
+                                break;
+                            }
+                        }
+
+                        // It's an attachment of a valid avatar, but
+                        // doesn't seem to be attached, skip
+                        if (!found)
+                            continue;
+                    }
+                    if (part.ParentGroup.IsAttachment && m_disableFacelights)
+                    {
+                        if (part.ParentGroup.RootPart.Shape.State != (byte)AttachmentPoint.LeftHand &&
+                            part.ParentGroup.RootPart.Shape.State != (byte)AttachmentPoint.RightHand)
+                        {
+                            part.Shape.LightEntry = false;
+                        }
+                    }
+                }
+
+                ++updatesThisCall;
+
+                #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))
                 {
-                    priority = handler(new UpdatePriorityData(priority, local_id));
-                    return priority != double.NaN;
-                };
-            PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock>.UpdatePriorityHandler update_priority_handler =
-                delegate(ref double priority, uint local_id)
+                    canUseCompressed = false;
+                }
+
+                if (updateFlags.HasFlag(PrimUpdateFlags.FullUpdate))
+                {
+                    canUseCompressed = false;
+                    canUseImproved = false;
+                }
+                else
                 {
-                    priority = handler(new UpdatePriorityData(priority, local_id));
-                    return priority != double.NaN;
-                };
+                    if (updateFlags.HasFlag(PrimUpdateFlags.Velocity) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Acceleration) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.CollisionPlane) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Joint))
+                    {
+                        canUseCompressed = false;
+                    }
 
-            if ((type & StateUpdateTypes.AvatarTerse) != 0)
-            {
-                lock (m_avatarTerseUpdates.SyncRoot)
-                    m_avatarTerseUpdates.Reprioritize(terse_update_priority_handler);
-            }
+                    if (updateFlags.HasFlag(PrimUpdateFlags.PrimFlags) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.ParentID) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Scale) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.PrimData) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Text) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.NameValue) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.ExtraData) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.TextureAnim) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Sound) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Particles) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Material) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.ClickAction) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.MediaURL) ||
+                        updateFlags.HasFlag(PrimUpdateFlags.Joint))
+                    {
+                        canUseImproved = false;
+                    }
+                }
 
-            if ((type & StateUpdateTypes.PrimitiveFull) != 0)
-            {
-                lock (m_primFullUpdates.SyncRoot)
-                    m_primFullUpdates.Reprioritize(update_priority_handler);
+                #endregion UpdateFlags to packet type conversion
+
+                #region Block Construction
+
+                // TODO: Remove this once we can build compressed updates
+                canUseCompressed = false;
+
+                if (!canUseImproved && !canUseCompressed)
+                {
+                    if (update.Entity is ScenePresence)
+                    {
+                        objectUpdateBlocks.Value.Add(CreateAvatarUpdateBlock((ScenePresence)update.Entity));
+                    }
+                    else
+                    {
+                        objectUpdateBlocks.Value.Add(CreatePrimUpdateBlock((SceneObjectPart)update.Entity, this.m_agentId));
+                    }
+                }
+                else if (!canUseImproved)
+                {
+                    compressedUpdateBlocks.Value.Add(CreateCompressedUpdateBlock((SceneObjectPart)update.Entity, updateFlags));
+                }
+                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)));
+                    else
+                        // Everything else goes here
+                        terseUpdateBlocks.Value.Add(CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures)));
+                }
+
+                #endregion Block Construction
             }
 
-            if ((type & StateUpdateTypes.PrimitiveTerse) != 0)
+            #region Packet Sending
+    
+            const float TIME_DILATION = 1.0f;
+            ushort timeDilation = Utils.FloatToUInt16(avgTimeDilation, 0.0f, 1.0f);
+    
+            if (terseAgentUpdateBlocks.IsValueCreated)
             {
-                lock (m_primTerseUpdates.SyncRoot)
-                    m_primTerseUpdates.Reprioritize(terse_update_priority_handler);
+                List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> blocks = terseAgentUpdateBlocks.Value;
+
+                ImprovedTerseObjectUpdatePacket packet = new ImprovedTerseObjectUpdatePacket();
+                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];
+
+                OutPacket(packet, ThrottleOutPacketType.Unknown, true);
             }
-        }
 
-        public void FlushPrimUpdates()
-        {
-            while (m_primFullUpdates.Count > 0)
+            if (objectUpdateBlocks.IsValueCreated)
             {
-                ProcessPrimFullUpdates();
+                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];
+    
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
             }
-            while (m_primTerseUpdates.Count > 0)
+    
+            if (compressedUpdateBlocks.IsValueCreated)
             {
-                ProcessPrimTerseUpdates();
+                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];
+    
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
             }
-            while (m_avatarTerseUpdates.Count > 0)
+    
+            if (terseUpdateBlocks.IsValueCreated)
             {
-                ProcessAvatarTerseUpdates();
+                List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> blocks = terseUpdateBlocks.Value;
+    
+                ImprovedTerseObjectUpdatePacket packet = new ImprovedTerseObjectUpdatePacket();
+                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];
+    
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
             }
+
+            #endregion Packet Sending
         }
 
-        #endregion Primitive Packet/Data Sending Methods
+        public void ReprioritizeUpdates()
+        {
+            lock (m_entityUpdates.SyncRoot)
+                m_entityUpdates.Reprioritize(UpdatePriorityHandler);
+        }
 
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="localID"></param>
-        /// <param name="rotation"></param>
-        /// <param name="attachPoint"></param>
-        public void AttachObject(uint localID, Quaternion rotation, byte attachPoint, UUID ownerID)
+        private bool UpdatePriorityHandler(ref uint priority, ISceneEntity entity)
         {
-            if (attachPoint > 30 && ownerID != AgentId) // Someone else's HUD
-                return;
+            if (entity != null)
+            {
+                priority = m_prioritizer.GetUpdatePriority(this, entity);
+                return true;
+            }
 
-            ObjectAttachPacket attach = (ObjectAttachPacket)PacketPool.Instance.GetPacket(PacketType.ObjectAttach);
-            // TODO: don't create new blocks if recycling an old packet
-            attach.AgentData.AgentID = AgentId;
-            attach.AgentData.SessionID = m_sessionId;
-            attach.AgentData.AttachmentPoint = attachPoint;
-            attach.ObjectData = new ObjectAttachPacket.ObjectDataBlock[1];
-            attach.ObjectData[0] = new ObjectAttachPacket.ObjectDataBlock();
-            attach.ObjectData[0].ObjectLocalID = localID;
-            attach.ObjectData[0].Rotation = rotation;
-            attach.Header.Zerocoded = true;
-            OutPacket(attach, ThrottleOutPacketType.Task);
+            return false;
+        }
+
+        public void FlushPrimUpdates()
+        {
+            m_log.WarnFormat("[CLIENT]: Flushing prim updates to " + m_firstName + " " + m_lastName);
+
+            while (m_entityUpdates.Count > 0)
+                ProcessEntityUpdates(-1);
         }
 
+        #endregion Primitive Packet/Data Sending Methods
+
+        // These are used to implement an adaptive backoff in the number
+        // of updates converted to packets. Since we don't want packets
+        // to sit in the queue with old data, only convert enough updates
+        // to packets that can be sent in 200ms.
+        private Int32 m_LastQueueFill = 0;
+        private Int32 m_maxUpdates = 0;
+
         void HandleQueueEmpty(ThrottleOutPacketTypeFlags categories)
         {
             if ((categories & ThrottleOutPacketTypeFlags.Task) != 0)
             {
-                lock (m_avatarTerseUpdates.SyncRoot)
+                if (m_maxUpdates == 0 || m_LastQueueFill == 0)
                 {
-                    if (m_avatarTerseUpdates.Count > 0)
-                        ProcessAvatarTerseUpdates();
+                    m_maxUpdates = m_udpServer.PrimUpdatesPerCallback;
                 }
-            }
-
-            if ((categories & ThrottleOutPacketTypeFlags.State) != 0)
-            {
-                lock (m_primFullUpdates.SyncRoot)
+                else
                 {
-                    if (m_primFullUpdates.Count > 0)
-                        ProcessPrimFullUpdates();
+                    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);
 
-                lock (m_primTerseUpdates.SyncRoot)
-                {
-                    if (m_primTerseUpdates.Count > 0)
-                        ProcessPrimTerseUpdates();
-                }
+                if (m_entityProps.Count > 0)
+                    ProcessEntityPropertyRequests(m_maxUpdates);
             }
 
             if ((categories & ThrottleOutPacketTypeFlags.Texture) != 0)
@@ -3862,135 +4089,250 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(pack, ThrottleOutPacketType.Task);
         }
 
-        public void SendObjectPropertiesFamilyData(uint RequestFlags, UUID ObjectUUID, UUID OwnerID, UUID GroupID,
-                                                    uint BaseMask, uint OwnerMask, uint GroupMask, uint EveryoneMask,
-                                                    uint NextOwnerMask, int OwnershipCost, byte SaleType, int SalePrice, uint Category,
-                                                    UUID LastOwnerID, string ObjectName, string Description)
+        private class ObjectPropertyUpdate : IEntityUpdate
         {
-            ObjectPropertiesFamilyPacket objPropFamilyPack = (ObjectPropertiesFamilyPacket)PacketPool.Instance.GetPacket(PacketType.ObjectPropertiesFamily);
-            // TODO: don't create new blocks if recycling an old packet
+            internal bool SendFamilyProps;
+            internal bool SendObjectProps;
+            
+            public ObjectPropertyUpdate(ISceneEntity entity, uint flags, bool sendfam, bool sendobj)
+                : base(entity,flags)
+            {
+                SendFamilyProps = sendfam;
+                SendObjectProps = sendobj;
+            }
+            public void Update(ObjectPropertyUpdate update)
+            {
+                SendFamilyProps = SendFamilyProps || update.SendFamilyProps;
+                SendObjectProps = SendObjectProps || update.SendObjectProps;
+                // other properties may need to be updated by base class
+                base.Update(update);
+            }
+        }
+        
+        public void SendObjectPropertiesFamilyData(ISceneEntity entity, uint requestFlags)
+        {
+            uint priority = 0;  // time based ordering only
+            lock (m_entityProps.SyncRoot)
+                m_entityProps.Enqueue(priority, new ObjectPropertyUpdate(entity,requestFlags,true,false));
+        }
 
-            ObjectPropertiesFamilyPacket.ObjectDataBlock objPropDB = new ObjectPropertiesFamilyPacket.ObjectDataBlock();
-            objPropDB.RequestFlags = RequestFlags;
-            objPropDB.ObjectID = ObjectUUID;
-            if (OwnerID == GroupID)
-                objPropDB.OwnerID = UUID.Zero;
-            else
-                objPropDB.OwnerID = OwnerID;
-            objPropDB.GroupID = GroupID;
-            objPropDB.BaseMask = BaseMask;
-            objPropDB.OwnerMask = OwnerMask;
-            objPropDB.GroupMask = GroupMask;
-            objPropDB.EveryoneMask = EveryoneMask;
-            objPropDB.NextOwnerMask = NextOwnerMask;
+        private void ResendPropertyUpdate(ObjectPropertyUpdate update)
+        {
+            uint priority = 0;
+            lock (m_entityProps.SyncRoot)
+                m_entityProps.Enqueue(priority, update);
+        }
 
-            // TODO: More properties are needed in SceneObjectPart!
-            objPropDB.OwnershipCost = OwnershipCost;
-            objPropDB.SaleType = SaleType;
-            objPropDB.SalePrice = SalePrice;
-            objPropDB.Category = Category;
-            objPropDB.LastOwnerID = LastOwnerID;
-            objPropDB.Name = Util.StringToBytes256(ObjectName);
-            objPropDB.Description = Util.StringToBytes256(Description);
-            objPropFamilyPack.ObjectData = objPropDB;
-            objPropFamilyPack.Header.Zerocoded = true;
-            OutPacket(objPropFamilyPack, ThrottleOutPacketType.Task);
-        }
-
-        public void SendObjectPropertiesReply(
-            UUID ItemID, ulong CreationDate, UUID CreatorUUID, UUID FolderUUID, UUID FromTaskUUID,
-            UUID GroupUUID, short InventorySerial, UUID LastOwnerUUID, UUID ObjectUUID,
-            UUID OwnerUUID, string TouchTitle, byte[] TextureID, string SitTitle, string ItemName,
-            string ItemDescription, uint OwnerMask, uint NextOwnerMask, uint GroupMask, uint EveryoneMask,
-            uint BaseMask, byte saleType, int salePrice)
+        private void ResendPropertyUpdates(List<ObjectPropertyUpdate> updates, OutgoingPacket oPacket)
         {
-            //ObjectPropertiesPacket proper = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
-            // TODO: don't create new blocks if recycling an old packet
+            // m_log.WarnFormat("[CLIENT] resending object property {0}",updates[0].UpdateTime);
 
-            ObjectPropertiesPacket.ObjectDataBlock block =
-                    new ObjectPropertiesPacket.ObjectDataBlock();
+            // Remove the update packet from the list of packets waiting for acknowledgement
+            // because we are requeuing the list of updates. They will be resent in new packets
+            // with the most recent state.
+            m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);
 
-            block.ItemID = ItemID;
-            block.CreationDate = CreationDate;
-            block.CreatorID = CreatorUUID;
-            block.FolderID = FolderUUID;
-            block.FromTaskID = FromTaskUUID;
-            block.GroupID = GroupUUID;
-            block.InventorySerial = InventorySerial;
+            // 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);
 
-            block.LastOwnerID = LastOwnerUUID;
-            //            proper.ObjectData[0].LastOwnerID = UUID.Zero;
+            foreach (ObjectPropertyUpdate update in updates)
+                ResendPropertyUpdate(update);
+        }
+        
+        public void SendObjectPropertiesReply(ISceneEntity entity)
+        {
+            uint priority = 0;  // time based ordering only
+            lock (m_entityProps.SyncRoot)
+                m_entityProps.Enqueue(priority, new ObjectPropertyUpdate(entity,0,false,true));
+        }
 
-            block.ObjectID = ObjectUUID;
-            if (OwnerUUID == GroupUUID)
-                block.OwnerID = UUID.Zero;
-            else
-                block.OwnerID = OwnerUUID;
-            block.TouchName = Util.StringToBytes256(TouchTitle);
-            block.TextureID = TextureID;
-            block.SitName = Util.StringToBytes256(SitTitle);
-            block.Name = Util.StringToBytes256(ItemName);
-            block.Description = Util.StringToBytes256(ItemDescription);
-            block.OwnerMask = OwnerMask;
-            block.NextOwnerMask = NextOwnerMask;
-            block.GroupMask = GroupMask;
-            block.EveryoneMask = EveryoneMask;
-            block.BaseMask = BaseMask;
-            //            proper.ObjectData[0].AggregatePerms = 53;
-            //            proper.ObjectData[0].AggregatePermTextures = 0;
-            //            proper.ObjectData[0].AggregatePermTexturesOwner = 0;
-            block.SaleType = saleType;
-            block.SalePrice = salePrice;
-
-            lock (m_propertiesPacketTimer)
-            {
-                m_propertiesBlocks.Add(block);
-
-                int length = 0;
-                foreach (ObjectPropertiesPacket.ObjectDataBlock b in m_propertiesBlocks)
-                {
-                    length += b.Length;
-                }
-                if (length > 1100) // FIXME: use real MTU
-                {
-                    ProcessObjectPropertiesPacket(null, null);
-                    m_propertiesPacketTimer.Stop();
-                    return;
+        private void ProcessEntityPropertyRequests(int maxUpdates)
+        {
+            OpenSim.Framework.Lazy<List<ObjectPropertiesFamilyPacket.ObjectDataBlock>> objectFamilyBlocks =
+                new OpenSim.Framework.Lazy<List<ObjectPropertiesFamilyPacket.ObjectDataBlock>>();
+
+            OpenSim.Framework.Lazy<List<ObjectPropertiesPacket.ObjectDataBlock>> objectPropertiesBlocks =
+                new OpenSim.Framework.Lazy<List<ObjectPropertiesPacket.ObjectDataBlock>>();
+
+            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> familyUpdates =
+                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
+
+            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> propertyUpdates =
+                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
+            
+            IEntityUpdate iupdate;
+            Int32 timeinqueue; // this is just debugging code & can be dropped later
+
+            int updatesThisCall = 0;
+            while (updatesThisCall < m_maxUpdates)
+            {
+                lock (m_entityProps.SyncRoot)
+                    if (!m_entityProps.TryDequeue(out iupdate, out timeinqueue))
+                        break;
+
+                ObjectPropertyUpdate update = (ObjectPropertyUpdate)iupdate;
+                if (update.SendFamilyProps)
+                {
+                    if (update.Entity is SceneObjectPart)
+                    {
+                        SceneObjectPart sop = (SceneObjectPart)update.Entity;
+                        ObjectPropertiesFamilyPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesFamilyBlock(sop,update.Flags);
+                        objectFamilyBlocks.Value.Add(objPropDB);
+                        familyUpdates.Value.Add(update);
+                    }
                 }
-                    
-                m_propertiesPacketTimer.Stop();
-                m_propertiesPacketTimer.Start();
+
+                if (update.SendObjectProps)
+                {
+                    if (update.Entity is SceneObjectPart)
+                    {
+                        SceneObjectPart sop = (SceneObjectPart)update.Entity;
+                        ObjectPropertiesPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesBlock(sop);
+                        objectPropertiesBlocks.Value.Add(objPropDB);
+                        propertyUpdates.Value.Add(update);
+                    }
+                }
+
+                updatesThisCall++;
             }
+            
 
-            //proper.Header.Zerocoded = true;
-            //OutPacket(proper, ThrottleOutPacketType.Task);
+            // Int32 ppcnt = 0;
+            // Int32 pbcnt = 0;
+            
+            if (objectPropertiesBlocks.IsValueCreated)
+            {
+                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.Header.Zerocoded = true;
+
+                // Pass in the delegate so that if this packet needs to be resent, we send the current properties
+                // of the object rather than the properties when the packet was created
+                // HACK : Remove intelligent resending until it's fixed in core
+                //OutPacket(packet, ThrottleOutPacketType.Task, true,
+                //          delegate(OutgoingPacket oPacket)
+                //          {
+                //              ResendPropertyUpdates(updates, oPacket);
+                //          });
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
+
+                // pbcnt += blocks.Count;
+                // ppcnt++;
+            }
+            
+            // Int32 fpcnt = 0;
+            // Int32 fbcnt = 0;
+            
+            if (objectFamilyBlocks.IsValueCreated)
+            {
+                List<ObjectPropertiesFamilyPacket.ObjectDataBlock> blocks = objectFamilyBlocks.Value;
+                
+                // one packet per object block... uggh...
+                for (int i = 0; i < blocks.Count; i++)
+                {
+                    ObjectPropertiesFamilyPacket packet =
+                        (ObjectPropertiesFamilyPacket)PacketPool.Instance.GetPacket(PacketType.ObjectPropertiesFamily);
+
+                    packet.ObjectData = blocks[i];
+                    packet.Header.Zerocoded = true;
+
+                    // Pass in the delegate so that if this packet needs to be resent, we send the current properties
+                    // of the object rather than the properties when the packet was created
+                    List<ObjectPropertyUpdate> updates = new List<ObjectPropertyUpdate>();
+                    updates.Add(familyUpdates.Value[i]);
+                    // HACK : Remove intelligent resending until it's fixed in core
+                    //OutPacket(packet, ThrottleOutPacketType.Task, true,
+                    //          delegate(OutgoingPacket oPacket)
+                    //          {
+                    //              ResendPropertyUpdates(updates, oPacket);
+                    //          });
+                    OutPacket(packet, ThrottleOutPacketType.Task, true);
+
+                    // fpcnt++;
+                    // fbcnt++;
+                }
+                
+            }
+            
+            // 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 void ProcessObjectPropertiesPacket(Object sender, ElapsedEventArgs e)
+        private ObjectPropertiesFamilyPacket.ObjectDataBlock CreateObjectPropertiesFamilyBlock(SceneObjectPart sop, uint requestFlags)
         {
-            ObjectPropertiesPacket proper = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
+            ObjectPropertiesFamilyPacket.ObjectDataBlock block = new ObjectPropertiesFamilyPacket.ObjectDataBlock();
 
-            lock (m_propertiesPacketTimer)
-            {
-                m_propertiesPacketTimer.Stop();
+            block.RequestFlags = requestFlags;
+            block.ObjectID = sop.UUID;
+            if (sop.OwnerID == sop.GroupID)
+                block.OwnerID = UUID.Zero;
+            else
+                block.OwnerID = sop.OwnerID;
+            block.GroupID = sop.GroupID;
+            block.BaseMask = sop.BaseMask;
+            block.OwnerMask = sop.OwnerMask;
+            block.GroupMask = sop.GroupMask;
+            block.EveryoneMask = sop.EveryoneMask;
+            block.NextOwnerMask = sop.NextOwnerMask;
 
-                if (m_propertiesBlocks.Count == 0)
-                    return;
+            // TODO: More properties are needed in SceneObjectPart!
+            block.OwnershipCost = sop.OwnershipCost;
+            block.SaleType = sop.ObjectSaleType;
+            block.SalePrice = sop.SalePrice;
+            block.Category = sop.Category;
+            block.LastOwnerID = sop.CreatorID; // copied from old SOG call... is this right?
+            block.Name = Util.StringToBytes256(sop.Name);
+            block.Description = Util.StringToBytes256(sop.Description);
 
-                proper.ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[m_propertiesBlocks.Count];
+            return block;
+        }
+    
+        private ObjectPropertiesPacket.ObjectDataBlock CreateObjectPropertiesBlock(SceneObjectPart sop)
+        {
+            //ObjectPropertiesPacket proper = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
+            // TODO: don't create new blocks if recycling an old packet
 
-                int index = 0;
+            ObjectPropertiesPacket.ObjectDataBlock block =
+                    new ObjectPropertiesPacket.ObjectDataBlock();
 
-                foreach (ObjectPropertiesPacket.ObjectDataBlock b in m_propertiesBlocks)
-                {
-                    proper.ObjectData[index++] = b;
-                }
+            block.ObjectID = sop.UUID;
+            block.Name = Util.StringToBytes256(sop.Name);
+            block.Description = Util.StringToBytes256(sop.Description);
 
-                m_propertiesBlocks.Clear();
-            }
+            block.CreationDate = (ulong)sop.CreationDate * 1000000; // viewer wants date in microseconds
+            block.CreatorID = sop.CreatorID;
+            block.GroupID = sop.GroupID;
+            block.LastOwnerID = sop.LastOwnerID;
+            if (sop.OwnerID == sop.GroupID)
+                block.OwnerID = UUID.Zero;
+            else
+                block.OwnerID = sop.OwnerID;
 
-            proper.Header.Zerocoded = true;
-            OutPacket(proper, ThrottleOutPacketType.Task);
+            block.ItemID = sop.FromUserInventoryItemID;
+            block.FolderID = UUID.Zero; // sop.FromFolderID ??
+            block.FromTaskID = UUID.Zero; // ???
+            block.InventorySerial = (short)sop.InventorySerial;
+            
+            SceneObjectPart root = sop.ParentGroup.RootPart;
+
+            block.TouchName = Util.StringToBytes256(root.TouchName);
+            block.TextureID = new byte[0]; // TextureID ???
+            block.SitName = Util.StringToBytes256(root.SitName);
+            block.OwnerMask = root.OwnerMask;
+            block.NextOwnerMask = root.NextOwnerMask;
+            block.GroupMask = root.GroupMask;
+            block.EveryoneMask = root.EveryoneMask;
+            block.BaseMask = root.BaseMask;
+            block.SaleType = root.ObjectSaleType;
+            block.SalePrice = root.SalePrice;
+
+            return block;
         }
 
         #region Estate Data Sending Methods
@@ -4059,37 +4401,44 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 if (bl[i].BannedUserID == UUID.Zero)
                     continue;
                 BannedUsers.Add(bl[i].BannedUserID);
-            }
 
-            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");
+                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];
+                    EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[6 + BannedUsers.Count];
 
-            for (int i = 0; i < (6 + BannedUsers.Count); i++)
-            {
-                returnblock[i] = new EstateOwnerMessagePacket.ParamListBlock();
-            }
-            int j = 0;
+                    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++;
+                    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++;
+                    foreach (UUID banned in BannedUsers)
+                    {
+                        returnblock[j].Parameter = banned.GetBytes(); j++;
+                    }
+                    packet.ParamList = returnblock;
+                    packet.Header.Reliable = true;
+                    OutPacket(packet, ThrottleOutPacketType.Task);
+
+                    BannedUsers.Clear();
+                }
             }
-            packet.ParamList = returnblock;
-            packet.Header.Reliable = false;
-            OutPacket(packet, ThrottleOutPacketType.Task);
+
         }
 
         public void SendRegionInfoToEstateMenu(RegionInfoForEstateMenuArgs args)
@@ -4119,7 +4468,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             rinfopack.RegionInfo2.HardMaxAgents = uint.MaxValue;
             rinfopack.RegionInfo2.HardMaxObjects = uint.MaxValue;
             rinfopack.RegionInfo2.MaxAgents32 = uint.MaxValue;
-            rinfopack.RegionInfo2.ProductName = Utils.EmptyBytes;
+            rinfopack.RegionInfo2.ProductName = Util.StringToBytes256(args.regionType);
             rinfopack.RegionInfo2.ProductSKU = Utils.EmptyBytes;
 
             rinfopack.HasVariableBlocks = true;
@@ -4134,21 +4483,25 @@ 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;
             edata.CovenantTimestamp = 0;
-            if (m_scene.RegionInfo.EstateSettings.EstateOwner != UUID.Zero)
-                edata.EstateOwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
-            else
-                edata.EstateOwnerID = m_scene.RegionInfo.MasterAvatarAssignedUUID;
+            edata.EstateOwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
             edata.EstateName = Utils.StringToBytes(m_scene.RegionInfo.EstateSettings.EstateName);
             einfopack.Data = edata;
             OutPacket(einfopack, ThrottleOutPacketType.Task);
         }
 
-        public void SendDetailedEstateData(UUID invoice, string estateName, uint estateID, uint parentEstate, uint estateFlags, uint sunPosition, UUID covenant, string abuseEmail, UUID estateOwner)
+        public void SendDetailedEstateData(
+            UUID invoice, string estateName, uint estateID, uint parentEstate, uint estateFlags, uint sunPosition, 
+            UUID covenant, string abuseEmail, UUID estateOwner)
         {
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Sending detailed estate data to {0} with covenant asset id {1}", Name, covenant);
+            
             EstateOwnerMessagePacket packet = new EstateOwnerMessagePacket();
             packet.MethodData.Invoice = invoice;
             packet.AgentData.TransactionID = UUID.Random();
@@ -4162,8 +4515,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             //Sending Estate Settings
             returnblock[0].Parameter = Utils.StringToBytes(estateName);
-            // TODO: remove this cruft once MasterAvatar is fully deprecated
-            //
             returnblock[1].Parameter = Utils.StringToBytes(estateOwner.ToString());
             returnblock[2].Parameter = Utils.StringToBytes(estateID.ToString());
 
@@ -4194,96 +4545,116 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(packet, ThrottleOutPacketType.Task);
         }
 
-        public void SendLandProperties(int sequence_id, bool snap_selection, int request_result, LandData landData, float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
+        public void SendLandProperties(
+             int sequence_id, bool snap_selection, int request_result, ILandObject lo, 
+             float simObjectBonusFactor, int parcelObjectCapacity, int simObjectCapacity, uint regionFlags)
         {
-            ParcelPropertiesPacket updatePacket = (ParcelPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ParcelProperties);
-            // TODO: don't create new blocks if recycling an old packet
-
-            updatePacket.ParcelData.AABBMax = landData.AABBMax;
-            updatePacket.ParcelData.AABBMin = landData.AABBMin;
-            updatePacket.ParcelData.Area = landData.Area;
-            updatePacket.ParcelData.AuctionID = landData.AuctionID;
-            updatePacket.ParcelData.AuthBuyerID = landData.AuthBuyerID;
-
-            updatePacket.ParcelData.Bitmap = landData.Bitmap;
-
-            updatePacket.ParcelData.Desc = Utils.StringToBytes(landData.Description);
-            updatePacket.ParcelData.Category = (byte)landData.Category;
-            updatePacket.ParcelData.ClaimDate = landData.ClaimDate;
-            updatePacket.ParcelData.ClaimPrice = landData.ClaimPrice;
-            updatePacket.ParcelData.GroupID = landData.GroupID;
-            updatePacket.ParcelData.GroupPrims = landData.GroupPrims;
-            updatePacket.ParcelData.IsGroupOwned = landData.IsGroupOwned;
-            updatePacket.ParcelData.LandingType = landData.LandingType;
-            updatePacket.ParcelData.LocalID = landData.LocalID;
+//            m_log.DebugFormat("[LLCLIENTVIEW]: Sending land properties for {0} to {1}", lo.LandData.GlobalID, Name);
+            
+            LandData landData = lo.LandData;
+            
+            ParcelPropertiesMessage updateMessage = new ParcelPropertiesMessage();
+
+            updateMessage.AABBMax = landData.AABBMax;
+            updateMessage.AABBMin = landData.AABBMin;
+            updateMessage.Area = landData.Area;
+            updateMessage.AuctionID = landData.AuctionID;
+            updateMessage.AuthBuyerID = landData.AuthBuyerID;
+            updateMessage.Bitmap = landData.Bitmap;
+            updateMessage.Desc = landData.Description;
+            updateMessage.Category = landData.Category;
+            updateMessage.ClaimDate = Util.ToDateTime(landData.ClaimDate);
+            updateMessage.ClaimPrice = landData.ClaimPrice;
+            updateMessage.GroupID = landData.GroupID;            
+            updateMessage.IsGroupOwned = landData.IsGroupOwned;
+            updateMessage.LandingType = (LandingType) landData.LandingType;
+            updateMessage.LocalID = landData.LocalID;
 
             if (landData.Area > 0)
             {
-                updatePacket.ParcelData.MaxPrims = parcelObjectCapacity;
+                updateMessage.MaxPrims = parcelObjectCapacity;
             }
             else
             {
-                updatePacket.ParcelData.MaxPrims = 0;
-            }
-
-            updatePacket.ParcelData.MediaAutoScale = landData.MediaAutoScale;
-            updatePacket.ParcelData.MediaID = landData.MediaID;
-            updatePacket.ParcelData.MediaURL = Util.StringToBytes256(landData.MediaURL);
-            updatePacket.ParcelData.MusicURL = Util.StringToBytes256(landData.MusicURL);
-            updatePacket.ParcelData.Name = Util.StringToBytes256(landData.Name);
-            updatePacket.ParcelData.OtherCleanTime = landData.OtherCleanTime;
-            updatePacket.ParcelData.OtherCount = 0; //TODO: Unimplemented
-            updatePacket.ParcelData.OtherPrims = landData.OtherPrims;
-            updatePacket.ParcelData.OwnerID = landData.OwnerID;
-            updatePacket.ParcelData.OwnerPrims = landData.OwnerPrims;
-            updatePacket.ParcelData.ParcelFlags = landData.Flags;
-            updatePacket.ParcelData.ParcelPrimBonus = simObjectBonusFactor;
-            updatePacket.ParcelData.PassHours = landData.PassHours;
-            updatePacket.ParcelData.PassPrice = landData.PassPrice;
-            updatePacket.ParcelData.PublicCount = 0; //TODO: Unimplemented
-
-            updatePacket.ParcelData.RegionDenyAnonymous = (regionFlags & (uint)RegionFlags.DenyAnonymous) > 0;
-            updatePacket.ParcelData.RegionDenyIdentified = (regionFlags & (uint)RegionFlags.DenyIdentified) > 0;
-            updatePacket.ParcelData.RegionDenyTransacted = (regionFlags & (uint)RegionFlags.DenyTransacted) > 0;
-            updatePacket.ParcelData.RegionPushOverride = (regionFlags & (uint)RegionFlags.RestrictPushObject) > 0;
-
-            updatePacket.ParcelData.RentPrice = 0;
-            updatePacket.ParcelData.RequestResult = request_result;
-            updatePacket.ParcelData.SalePrice = landData.SalePrice;
-            updatePacket.ParcelData.SelectedPrims = landData.SelectedPrims;
-            updatePacket.ParcelData.SelfCount = 0; //TODO: Unimplemented
-            updatePacket.ParcelData.SequenceID = sequence_id;
+                updateMessage.MaxPrims = 0;
+            }
+
+            updateMessage.MediaAutoScale = Convert.ToBoolean(landData.MediaAutoScale);
+            updateMessage.MediaID = landData.MediaID;
+            updateMessage.MediaURL = landData.MediaURL;
+            updateMessage.MusicURL = landData.MusicURL;
+            updateMessage.Name = landData.Name;
+            updateMessage.OtherCleanTime = landData.OtherCleanTime;
+            updateMessage.OtherCount = 0; //TODO: Unimplemented
+            updateMessage.OwnerID = landData.OwnerID;            
+            updateMessage.ParcelFlags = (ParcelFlags) landData.Flags;
+            updateMessage.ParcelPrimBonus = simObjectBonusFactor;
+            updateMessage.PassHours = landData.PassHours;
+            updateMessage.PassPrice = landData.PassPrice;
+            updateMessage.PublicCount = 0; //TODO: Unimplemented
+
+            updateMessage.RegionPushOverride = (regionFlags & (uint)RegionFlags.RestrictPushObject) > 0;
+            updateMessage.RegionDenyAnonymous = (regionFlags & (uint)RegionFlags.DenyAnonymous) > 0;
+
+            //updateMessage.RegionDenyIdentified = (regionFlags & (uint)RegionFlags.DenyIdentified) > 0;
+            //updateMessage.RegionDenyTransacted = (regionFlags & (uint)RegionFlags.DenyTransacted) > 0;
+
+            updateMessage.RentPrice = 0;
+            updateMessage.RequestResult = (ParcelResult) request_result;
+            updateMessage.SalePrice = landData.SalePrice;            
+            updateMessage.SelfCount = 0; //TODO: Unimplemented
+            updateMessage.SequenceID = sequence_id;
+            
             if (landData.SimwideArea > 0)
             {
-                updatePacket.ParcelData.SimWideMaxPrims = parcelObjectCapacity;
+                int simulatorCapacity = (int)((double)(landData.SimwideArea * m_scene.RegionInfo.ObjectCapacity) * m_scene.RegionInfo.RegionSettings.ObjectBonus) / 65536;
+                // Never report more than sim total capacity
+                if (simulatorCapacity > m_scene.RegionInfo.ObjectCapacity)
+                    simulatorCapacity = m_scene.RegionInfo.ObjectCapacity;
+                updateMessage.SimWideMaxPrims = simulatorCapacity;
             }
             else
             {
-                updatePacket.ParcelData.SimWideMaxPrims = 0;
+                updateMessage.SimWideMaxPrims = 0;
             }
-            updatePacket.ParcelData.SimWideTotalPrims = landData.SimwidePrims;
-            updatePacket.ParcelData.SnapSelection = snap_selection;
-            updatePacket.ParcelData.SnapshotID = landData.SnapshotID;
-            updatePacket.ParcelData.Status = (byte)landData.Status;
-            updatePacket.ParcelData.TotalPrims = landData.OwnerPrims + landData.GroupPrims + landData.OtherPrims +
-                                                 landData.SelectedPrims;
-            updatePacket.ParcelData.UserLocation = landData.UserLocation;
-            updatePacket.ParcelData.UserLookAt = landData.UserLookAt;
-            updatePacket.Header.Zerocoded = true;
+            
+            updateMessage.SnapSelection = snap_selection;
+            updateMessage.SnapshotID    = landData.SnapshotID;
+            updateMessage.Status        = (ParcelStatus) landData.Status;
+            updateMessage.UserLocation  = landData.UserLocation;
+            updateMessage.UserLookAt    = landData.UserLookAt;
+
+            updateMessage.MediaType     = landData.MediaType;
+            updateMessage.MediaDesc     = landData.MediaDescription;
+            updateMessage.MediaWidth    = landData.MediaWidth;
+            updateMessage.MediaHeight   = landData.MediaHeight;
+            updateMessage.MediaLoop     = landData.MediaLoop;
+            updateMessage.ObscureMusic  = landData.ObscureMusic;
+            updateMessage.ObscureMedia  = landData.ObscureMedia;
+            
+            IPrimCounts pc = lo.PrimCounts;
+            updateMessage.OwnerPrims        = pc.Owner;            
+            updateMessage.GroupPrims        = pc.Group;
+            updateMessage.OtherPrims        = pc.Others;            
+            updateMessage.SelectedPrims     = pc.Selected;
+            updateMessage.TotalPrims        = pc.Total;
+            updateMessage.SimWideTotalPrims = pc.Simulator;
 
             try
             {
                 IEventQueue eq = Scene.RequestModuleInterface<IEventQueue>();
                 if (eq != null)
                 {
-                    eq.ParcelProperties(updatePacket, this.AgentId);
+                    eq.ParcelProperties(updateMessage, this.AgentId);
+                } 
+                else 
+                {
+                    m_log.Warn("[LLCLIENTVIEW]: No EQ Interface when sending parcel data.");
                 }
             }
             catch (Exception ex)
             {
-                m_log.Error("Unable to send parcel data via eventqueue - exception: " + ex.ToString());
-                m_log.Warn("sending parcel data via UDP");
-                OutPacket(updatePacket, ThrottleOutPacketType.Task);
+                m_log.Error("[LLCLIENTVIEW]: Unable to send parcel data via eventqueue - exception: " + ex.ToString());
             }
         }
 
@@ -4312,6 +4683,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendForceClientSelectObjects(List<uint> ObjectIDs)
         {
+            m_log.WarnFormat("[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);
@@ -4361,21 +4734,19 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendLandObjectOwners(LandData land, List<UUID> groups, Dictionary<UUID, int> ownersAndCount)
         {
-
-
             int notifyCount = ownersAndCount.Count;
             ParcelObjectOwnersReplyPacket pack = (ParcelObjectOwnersReplyPacket)PacketPool.Instance.GetPacket(PacketType.ParcelObjectOwnersReply);
 
             if (notifyCount > 0)
             {
-                if (notifyCount > 32)
-                {
-                    m_log.InfoFormat(
-                        "[LAND]: More than {0} avatars own prims on this parcel.  Only sending back details of first {0}"
-                        + " - a developer might want to investigate whether this is a hard limit", 32);
-
-                    notifyCount = 32;
-                }
+//                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];
@@ -4414,22 +4785,66 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         #region Helper Methods
 
-        protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(SendAvatarTerseData data)
+        protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(ISceneEntity entity, bool sendTexture)
         {
-            return CreateImprovedTerseBlock(true, data.LocalID, 0, data.CollisionPlane, data.Position, data.Velocity,
-                data.Acceleration, data.Rotation, Vector3.Zero, data.TextureEntry);
-        }
+            #region ScenePresence/SOP Handling
 
-        protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(SendPrimitiveTerseData data)
-        {
-            return CreateImprovedTerseBlock(false, data.LocalID, data.AttachPoint, Vector4.Zero, data.Position, data.Velocity,
-                data.Acceleration, data.Rotation, data.AngularVelocity, data.TextureEntry);
-        }
+            bool avatar = (entity is ScenePresence);
+            uint localID = entity.LocalId;
+            uint attachPoint;
+            Vector4 collisionPlane;
+            Vector3 position, velocity, acceleration, angularVelocity;
+            Quaternion rotation;
+            byte[] textureEntry;
+
+            if (entity is ScenePresence)
+            {
+                ScenePresence presence = (ScenePresence)entity;
+
+                attachPoint = 0;
+                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 = Vector3.Zero;
+                rotation = presence.Rotation;
+
+                if (sendTexture)
+                    textureEntry = presence.Appearance.Texture.GetBytes();
+                else
+                    textureEntry = null;
+            }
+            else
+            {
+                SceneObjectPart part = (SceneObjectPart)entity;
+
+                attachPoint = part.ParentGroup.AttachmentPoint;
+
+//                m_log.DebugFormat(
+//                    "[LLCLIENTVIEW]: Sending attachPoint {0} for {1} {2} to {3}",
+//                    attachPoint, part.Name, part.LocalId, Name);
+
+                collisionPlane = Vector4.Zero;
+                position = part.RelativePosition;
+                velocity = part.Velocity;
+                acceleration = part.Acceleration;
+                angularVelocity = part.AngularVelocity;
+                rotation = part.RotationOffset;
+
+                if (sendTexture)
+                    textureEntry = part.Shape.TextureEntry;
+                else
+                    textureEntry = null;
+            }
+
+            #endregion ScenePresence/SOP Handling
 
-        protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(bool avatar, uint localID, int attachPoint,
-            Vector4 collisionPlane, Vector3 position, Vector3 velocity, Vector3 acceleration, Quaternion rotation,
-            Vector3 angularVelocity, byte[] textureEntry)
-        {
             int pos = 0;
             byte[] data = new byte[(avatar ? 60 : 44)];
 
@@ -4501,14 +4916,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return block;
         }
 
-        protected ObjectUpdatePacket.ObjectDataBlock CreateAvatarUpdateBlock(SendAvatarData data)
+        protected ObjectUpdatePacket.ObjectDataBlock CreateAvatarUpdateBlock(ScenePresence data)
         {
             byte[] objectData = new byte[76];
 
-            Vector4.UnitW.ToBytes(objectData, 0); // TODO: Collision plane support
-            data.Position.ToBytes(objectData, 16);
-            //data.Velocity.ToBytes(objectData, 28);
-            //data.Acceleration.ToBytes(objectData, 40);
+            data.CollisionPlane.ToBytes(objectData, 0);
+            data.OffsetPosition.ToBytes(objectData, 16);
+//            data.Velocity.ToBytes(objectData, 28);
+//            data.Acceleration.ToBytes(objectData, 40);
             data.Rotation.ToBytes(objectData, 52);
             //data.AngularVelocity.ToBytes(objectData, 64);
 
@@ -4516,12 +4931,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             update.Data = Utils.EmptyBytes;
             update.ExtraParams = new byte[1];
-            update.FullID = data.AvatarID;
-            update.ID = data.AvatarLocalID;
+            update.FullID = data.UUID;
+            update.ID = data.LocalId;
             update.Material = (byte)Material.Flesh;
             update.MediaURL = Utils.EmptyBytes;
-            update.NameValue = Utils.StringToBytes("FirstName STRING RW SV " + data.FirstName + "\nLastName STRING RW SV " +
-                data.LastName + "\nTitle STRING RW SV " + data.GroupTitle);
+            update.NameValue = Utils.StringToBytes("FirstName STRING RW SV " + data.Firstname + "\nLastName STRING RW SV " +
+                data.Lastname + "\nTitle STRING RW SV " + data.Grouptitle);
             update.ObjectData = objectData;
             update.ParentID = data.ParentID;
             update.PathCurve = 16;
@@ -4530,107 +4945,136 @@ 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 = new Vector3(0.45f, 0.6f, 1.9f);
             update.Text = Utils.EmptyBytes;
             update.TextColor = new byte[4];
             update.TextureAnim = Utils.EmptyBytes;
-            update.TextureEntry = data.TextureEntry ?? Utils.EmptyBytes;
-            update.UpdateFlags = (uint)(PrimFlags.Physics | PrimFlags.ObjectModify | PrimFlags.ObjectCopy | PrimFlags.ObjectAnyOwner | PrimFlags.ObjectYouOwner | PrimFlags.ObjectMove | PrimFlags.InventoryEmpty | PrimFlags.ObjectTransfer | PrimFlags.ObjectOwnerModify);//61 + (9 << 8) + (130 << 16) + (16 << 24); // TODO: Replace these numbers with PrimFlags
+            update.TextureEntry = (data.Appearance.Texture != null) ? data.Appearance.Texture.GetBytes() : Utils.EmptyBytes;
+            update.UpdateFlags = (uint)(
+                PrimFlags.Physics | PrimFlags.ObjectModify | PrimFlags.ObjectCopy | PrimFlags.ObjectAnyOwner |
+                PrimFlags.ObjectYouOwner | PrimFlags.ObjectMove | PrimFlags.InventoryEmpty | PrimFlags.ObjectTransfer |
+                PrimFlags.ObjectOwnerModify);
 
             return update;
         }
 
-        protected ObjectUpdatePacket.ObjectDataBlock CreatePrimUpdateBlock(SendPrimitiveData data)
+        protected ObjectUpdatePacket.ObjectDataBlock CreatePrimUpdateBlock(SceneObjectPart data, UUID recipientID)
         {
-//          if (data.attachment)
-//                m_log.DebugFormat(
-//                    "[LLCLIENTVIEW]: Creating prim update block for {0}, parent {1}, priority {2}", 
-//                    data.localID, data.parentID, data.priority); 
-                                  
             byte[] objectData = new byte[60];
-            data.pos.ToBytes(objectData, 0);
-            data.vel.ToBytes(objectData, 12);
-            data.acc.ToBytes(objectData, 24);
-            data.rotation.ToBytes(objectData, 36);
-            data.rvel.ToBytes(objectData, 48);
+            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);
 
             ObjectUpdatePacket.ObjectDataBlock update = new ObjectUpdatePacket.ObjectDataBlock();
-            update.ClickAction = (byte)data.clickAction;
+            update.ClickAction = (byte)data.ClickAction;
             update.CRC = 0;
-            update.ExtraParams = data.primShape.ExtraParams ?? Utils.EmptyBytes;
-            update.FullID = data.objectID;
-            update.ID = data.localID;
+            update.ExtraParams = data.Shape.ExtraParams ?? Utils.EmptyBytes;
+            update.FullID = data.UUID;
+            update.ID = data.LocalId;
             //update.JointAxisOrAnchor = Vector3.Zero; // These are deprecated
             //update.JointPivot = Vector3.Zero;
             //update.JointType = 0;
-            update.Material = data.material;
+            update.Material = data.Material;
             update.MediaURL = Utils.EmptyBytes; // FIXME: Support this in OpenSim
-            if (data.attachment)
+            if (data.ParentGroup.IsAttachment)
             {
-                update.NameValue = Util.StringToBytes256("AttachItemID STRING RW SV " + data.AssetId);
-                update.State = (byte)((data.AttachPoint % 16) * 16 + (data.AttachPoint / 16));
+                update.NameValue = Util.StringToBytes256("AttachItemID STRING RW SV " + data.FromItemID);
+                update.State = (byte)((data.ParentGroup.AttachmentPoint % 16) * 16 + (data.ParentGroup.AttachmentPoint / 16));
             }
             else
             {
                 update.NameValue = Utils.EmptyBytes;
-                update.State = data.primShape.State;
+
+                // The root part state is the canonical state for all parts of the object.  The other part states in the
+                // case for attachments may contain conflicting values that can end up crashing the viewer.
+                update.State = data.ParentGroup.RootPart.Shape.State;
             }
+
+//                m_log.DebugFormat(
+//                    "[LLCLIENTVIEW]: Sending state {0} for {1} {2} to {3}",
+//                    update.State, data.Name, data.LocalId, Name);
+
             update.ObjectData = objectData;
-            update.ParentID = data.parentID;
-            update.PathBegin = data.primShape.PathBegin;
-            update.PathCurve = data.primShape.PathCurve;
-            update.PathEnd = data.primShape.PathEnd;
-            update.PathRadiusOffset = data.primShape.PathRadiusOffset;
-            update.PathRevolutions = data.primShape.PathRevolutions;
-            update.PathScaleX = data.primShape.PathScaleX;
-            update.PathScaleY = data.primShape.PathScaleY;
-            update.PathShearX = data.primShape.PathShearX;
-            update.PathShearY = data.primShape.PathShearY;
-            update.PathSkew = data.primShape.PathSkew;
-            update.PathTaperX = data.primShape.PathTaperX;
-            update.PathTaperY = data.primShape.PathTaperY;
-            update.PathTwist = data.primShape.PathTwist;
-            update.PathTwistBegin = data.primShape.PathTwistBegin;
-            update.PCode = data.primShape.PCode;
-            update.ProfileBegin = data.primShape.ProfileBegin;
-            update.ProfileCurve = data.primShape.ProfileCurve;
-            update.ProfileEnd = data.primShape.ProfileEnd;
-            update.ProfileHollow = data.primShape.ProfileHollow;
-            update.PSBlock = data.particleSystem ?? Utils.EmptyBytes;
-            update.TextColor = data.color ?? Color4.Black.GetBytes(true);
-            update.TextureAnim = data.textureanim ?? Utils.EmptyBytes;
-            update.TextureEntry = data.primShape.TextureEntry ?? Utils.EmptyBytes;
-            update.Scale = data.primShape.Scale;
-            update.Text = Util.StringToBytes256(data.text);
-            update.UpdateFlags = (uint)data.flags;
-
-            if (data.SoundId != UUID.Zero)
-            {
-                update.Sound = data.SoundId;
-                update.OwnerID = data.ownerID;
-                update.Gain = (float)data.SoundVolume;
+            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);
+
+            #region PrimFlags
+
+            PrimFlags flags = (PrimFlags)m_scene.Permissions.GenerateClientFlags(recipientID, data.UUID);
+
+            // Don't send the CreateSelected flag to everyone
+            flags &= ~PrimFlags.CreateSelected;
+
+            if (recipientID == data.OwnerID)
+            {
+                if (data.CreateSelected)
+                {
+                    // Only send this flag once, then unset it
+                    flags |= PrimFlags.CreateSelected;
+                    data.CreateSelected = false;
+                }
+            }
+
+//            m_log.DebugFormat(
+//                "[LLCLIENTVIEW]: Constructing client update for part {0} {1} with flags {2}, localId {3}",
+//                data.Name, update.FullID, flags, update.ID);
+
+            update.UpdateFlags = (uint)flags;
+
+            #endregion PrimFlags
+
+            if (data.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;
             }
 
-            switch ((PCode)data.primShape.PCode)
+            switch ((PCode)data.Shape.PCode)
             {
                 case PCode.Grass:
                 case PCode.Tree:
                 case PCode.NewTree:
-                    update.Data = new byte[] { data.primShape.State };
+                    update.Data = new byte[] { data.Shape.State };
                     break;
                 default:
-                    // TODO: Support ScratchPad
-                    //if (prim.ScratchPad != null)
-                    //{
-                    //    update.Data = new byte[prim.ScratchPad.Length];
-                    //    Buffer.BlockCopy(prim.ScratchPad, 0, update.Data, 0, update.Data.Length);
-                    //}
-                    //else
-                    //{
-                    //    update.Data = Utils.EmptyBytes;
-                    //}
                     update.Data = Utils.EmptyBytes;
                     break;
             }
@@ -4638,6 +5082,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return update;
         }
 
+        protected ObjectUpdateCompressedPacket.ObjectDataBlock CreateCompressedUpdateBlock(SceneObjectPart part, PrimUpdateFlags updateFlags)
+        {
+            // TODO: Implement this
+            return null;
+        }
+
         public void SendNameReply(UUID profileId, string firstname, string lastname)
         {
             UUIDNameReplyPacket packet = (UUIDNameReplyPacket)PacketPool.Instance.GetPacket(PacketType.UUIDNameReply);
@@ -4736,7 +5186,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.ObjectScale, HandleObjectScale);
             AddLocalPacketHandler(PacketType.ObjectRotation, HandleObjectRotation);
             AddLocalPacketHandler(PacketType.ObjectFlagUpdate, HandleObjectFlagUpdate);
-            AddLocalPacketHandler(PacketType.ObjectImage, HandleObjectImage);
+
+            // Handle ObjectImage (TextureEntry) updates synchronously, since when updating multiple prim faces at once,
+            // some clients will send out a separate ObjectImage packet for each face
+            AddLocalPacketHandler(PacketType.ObjectImage, HandleObjectImage, false);
+
             AddLocalPacketHandler(PacketType.ObjectGrab, HandleObjectGrab, false);
             AddLocalPacketHandler(PacketType.ObjectGrabUpdate, HandleObjectGrabUpdate, false);
             AddLocalPacketHandler(PacketType.ObjectDeGrab, HandleObjectDeGrab);
@@ -4766,6 +5220,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.UpdateInventoryFolder, HandleUpdateInventoryFolder);
             AddLocalPacketHandler(PacketType.MoveInventoryFolder, HandleMoveInventoryFolder);
             AddLocalPacketHandler(PacketType.CreateInventoryItem, HandleCreateInventoryItem);
+            AddLocalPacketHandler(PacketType.LinkInventoryItem, HandleLinkInventoryItem);
             AddLocalPacketHandler(PacketType.FetchInventory, HandleFetchInventory);
             AddLocalPacketHandler(PacketType.FetchInventoryDescendents, HandleFetchInventoryDescendents);
             AddLocalPacketHandler(PacketType.PurgeInventoryDescendents, HandlePurgeInventoryDescendents);
@@ -4787,7 +5242,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.TeleportLocationRequest, HandleTeleportLocationRequest);
             AddLocalPacketHandler(PacketType.UUIDNameRequest, HandleUUIDNameRequest, false);
             AddLocalPacketHandler(PacketType.RegionHandleRequest, HandleRegionHandleRequest);
-            AddLocalPacketHandler(PacketType.ParcelInfoRequest, HandleParcelInfoRequest, false);
+            AddLocalPacketHandler(PacketType.ParcelInfoRequest, HandleParcelInfoRequest);
             AddLocalPacketHandler(PacketType.ParcelAccessListRequest, HandleParcelAccessListRequest, false);
             AddLocalPacketHandler(PacketType.ParcelAccessListUpdate, HandleParcelAccessListUpdate, false);
             AddLocalPacketHandler(PacketType.ParcelPropertiesRequest, HandleParcelPropertiesRequest, false);
@@ -4825,6 +5280,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);
@@ -4891,6 +5347,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.GroupVoteHistoryRequest, HandleGroupVoteHistoryRequest);
             AddLocalPacketHandler(PacketType.SimWideDeletes, HandleSimWideDeletes);
             AddLocalPacketHandler(PacketType.SendPostcard, HandleSendPostcard);
+            AddLocalPacketHandler(PacketType.ChangeInventoryItemFlags, HandleChangeInventoryItemFlags);
+
+            AddGenericPacketHandler("autopilot", HandleAutopilot);
         }
 
         #region Packet Handlers
@@ -4934,7 +5393,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                        );
                 }
                 else
+                {
                     update = true;
+                }
 
                 // These should be ordered from most-likely to
                 // least likely to change. I've made an initial
@@ -4942,6 +5403,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 if (update)
                 {
+//                    m_log.DebugFormat("[LLCLIENTVIEW]: Triggered AgentUpdate for {0}", sener.Name);
+
                     AgentUpdateArgs arg = new AgentUpdateArgs();
                     arg.AgentID = x.AgentID;
                     arg.BodyRotation = x.BodyRotation;
@@ -4956,11 +5419,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     arg.SessionID = x.SessionID;
                     arg.State = x.State;
                     UpdateAgent handlerAgentUpdate = OnAgentUpdate;
+                    UpdateAgent handlerPreAgentUpdate = OnPreAgentUpdate;
                     lastarg = arg; // save this set of arguments for nexttime
+                    if (handlerPreAgentUpdate != null)
+                        OnPreAgentUpdate(this, arg);
                     if (handlerAgentUpdate != null)
                         OnAgentUpdate(this, arg);
 
                     handlerAgentUpdate = null;
+                    handlerPreAgentUpdate = null;
                 }
             }
 
@@ -4987,12 +5454,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             return false;
         }
-        
+
         private bool HandleParcelGodMarkAsContent(IClientAPI client, Packet Packet)
         {
             ParcelGodMarkAsContentPacket ParcelGodMarkAsContent =
                 (ParcelGodMarkAsContentPacket)Packet;
-            
+
             ParcelGodMark ParcelGodMarkAsContentHandler = OnParcelGodMark;
             if (ParcelGodMarkAsContentHandler != null)
             {
@@ -5003,11 +5470,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleFreezeUser(IClientAPI client, Packet Packet)
         {
             FreezeUserPacket FreezeUser = (FreezeUserPacket)Packet;
-            
+
             FreezeUserUpdate FreezeUserHandler = OnParcelFreezeUser;
             if (FreezeUserHandler != null)
             {
@@ -5019,12 +5486,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleEjectUser(IClientAPI client, Packet Packet)
         {
             EjectUserPacket EjectUser =
                 (EjectUserPacket)Packet;
-            
+
             EjectUserUpdate EjectUserHandler = OnParcelEjectUser;
             if (EjectUserHandler != null)
             {
@@ -5036,12 +5503,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleParcelBuyPass(IClientAPI client, Packet Packet)
         {
             ParcelBuyPassPacket ParcelBuyPass =
                 (ParcelBuyPassPacket)Packet;
-            
+
             ParcelBuyPass ParcelBuyPassHandler = OnParcelBuyPass;
             if (ParcelBuyPassHandler != null)
             {
@@ -5052,7 +5519,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleParcelBuyRequest(IClientAPI sender, Packet Pack)
         {
             ParcelBuyPacket parcel = (ParcelBuyPacket)Pack;
@@ -5122,11 +5589,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     catch (Exception e)
                     {
-                        m_log.Error("[GENERICMESSAGE] " + e);
+                        m_log.ErrorFormat(
+                            "[LLCLIENTVIEW]: Exeception when handling generic message {0}{1}", e.Message, e.StackTrace);
                     }
                 }
             }
-            m_log.Error("[GENERICMESSAGE] Not handling GenericMessage with method-type of: " + method);
+            
+            //m_log.Debug("[LLCLIENTVIEW]: Not handling GenericMessage with method-type of: " + method);
             return false;
         }
 
@@ -5274,7 +5743,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             ScriptDialogReplyPacket rdialog = (ScriptDialogReplyPacket)Pack;
 
             //m_log.DebugFormat("[CLIENT]: Received ScriptDialogReply from {0}", rdialog.Data.ObjectID);
-            
+
             #region Packet Session and User Check
             if (m_checkPackets)
             {
@@ -5420,12 +5889,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return true;
         }
-        
+
         private bool HandleFindAgent(IClientAPI client, Packet Packet)
         {
             FindAgentPacket FindAgent =
                 (FindAgentPacket)Packet;
-            
+
             FindAgentUpdate FindAgentHandler = OnFindAgent;
             if (FindAgentHandler != null)
             {
@@ -5434,12 +5903,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleTrackAgent(IClientAPI client, Packet Packet)
         {
             TrackAgentPacket TrackAgent =
                 (TrackAgentPacket)Packet;
-            
+
             TrackAgentUpdate TrackAgentHandler = OnTrackAgent;
             if (TrackAgentHandler != null)
             {
@@ -5450,7 +5919,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandlerRezObject(IClientAPI sender, Packet Pack)
         {
             RezObjectPacket rezPacket = (RezObjectPacket)Pack;
@@ -5559,11 +6028,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private bool HandlerAgentWearablesRequest(IClientAPI sender, Packet Pack)
         {
-            GenericCall2 handlerRequestWearables = OnRequestWearables;
+            GenericCall1 handlerRequestWearables = OnRequestWearables;
 
             if (handlerRequestWearables != null)
             {
-                handlerRequestWearables();
+                handlerRequestWearables(sender);
             }
 
             Action<IClientAPI> handlerRequestAvatarsData = OnRequestAvatarsData;
@@ -5597,6 +6066,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 // for the client session anyway, in order to protect ourselves against bad code in plugins
                 try
                 {
+
                     byte[] visualparams = new byte[appear.VisualParam.Length];
                     for (int i = 0; i < appear.VisualParam.Length; i++)
                         visualparams[i] = appear.VisualParam[i].ParamValue;
@@ -5605,7 +6075,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     if (appear.ObjectData.TextureEntry.Length > 1)
                         te = new Primitive.TextureEntry(appear.ObjectData.TextureEntry, 0, appear.ObjectData.TextureEntry.Length);
 
-                    handlerSetAppearance(te, visualparams);
+                    handlerSetAppearance(sender, te, visualparams);
                 }
                 catch (Exception e)
                 {
@@ -5636,6 +6106,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 AvatarWearingArgs wearingArgs = new AvatarWearingArgs();
                 for (int i = 0; i < nowWearing.WearableData.Length; i++)
                 {
+                    //m_log.DebugFormat("[XXX]: Wearable type {0} item {1}", nowWearing.WearableData[i].WearableType, nowWearing.WearableData[i].ItemID);
                     AvatarWearingArgs.Wearable wearable =
                         new AvatarWearingArgs.Wearable(nowWearing.WearableData[i].ItemID,
                                                        nowWearing.WearableData[i].WearableType);
@@ -5679,9 +6150,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             RezMultipleAttachmentsFromInv handlerRezMultipleAttachments = OnRezMultipleAttachmentsFromInv;
             if (handlerRezMultipleAttachments != null)
             {
-                RezMultipleAttachmentsFromInvPacket rez = (RezMultipleAttachmentsFromInvPacket)Pack;
-                handlerRezMultipleAttachments(this, rez.HeaderData,
-                                              rez.ObjectData);
+                List<KeyValuePair<UUID, uint>> rezlist = new List<KeyValuePair<UUID, uint>>();
+                foreach (RezMultipleAttachmentsFromInvPacket.ObjectDataBlock obj in ((RezMultipleAttachmentsFromInvPacket)Pack).ObjectData)
+                    rezlist.Add(new KeyValuePair<UUID, uint>(obj.ItemID, obj.AttachmentPt));
+                handlerRezMultipleAttachments(this, rezlist);
             }
 
             return true;
@@ -5727,7 +6199,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 {
                     if (att.ObjectData.Length > 0)
                     {
-                        handlerObjectAttach(this, att.ObjectData[0].ObjectLocalID, att.AgentData.AttachmentPoint, att.ObjectData[0].Rotation, false);
+                        handlerObjectAttach(this, att.ObjectData[0].ObjectLocalID, att.AgentData.AttachmentPoint, false);
                     }
                 }
             }
@@ -5807,10 +6279,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private bool HandleCompleteAgentMovement(IClientAPI sender, Packet Pack)
         {
-            GenericCall2 handlerCompleteMovementToRegion = OnCompleteMovementToRegion;
+            Action<IClientAPI, bool> handlerCompleteMovementToRegion = OnCompleteMovementToRegion;
             if (handlerCompleteMovementToRegion != null)
             {
-                handlerCompleteMovementToRegion();
+                handlerCompleteMovementToRegion(sender, true);
             }
             handlerCompleteMovementToRegion = null;
 
@@ -5916,8 +6388,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             SoundTrigger handlerSoundTrigger = OnSoundTrigger;
             if (handlerSoundTrigger != null)
             {
-                handlerSoundTrigger(soundTriggerPacket.SoundData.SoundID, soundTriggerPacket.SoundData.OwnerID,
-                    soundTriggerPacket.SoundData.ObjectID, soundTriggerPacket.SoundData.ParentID,
+                // UUIDS are sent as zeroes by the client, substitute agent's id
+                handlerSoundTrigger(soundTriggerPacket.SoundData.SoundID, AgentId,
+                    AgentId, AgentId,
                     soundTriggerPacket.SoundData.Gain, soundTriggerPacket.SoundData.Position,
                     soundTriggerPacket.SoundData.Handle, 0);
 
@@ -6038,7 +6511,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     || avSetStartLocationRequestPacket.StartLocationData.LocationPos.Y == 255.5f)
                 {
                     ScenePresence avatar = null;
-                    if (((Scene)m_scene).TryGetAvatar(AgentId, out avatar))
+                    if (((Scene)m_scene).TryGetScenePresence(AgentId, out avatar))
                     {
                         if (avSetStartLocationRequestPacket.StartLocationData.LocationPos.X == 255.5f)
                         {
@@ -6287,7 +6760,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             #endregion
 
-            ObjectDuplicatePacket.AgentDataBlock AgentandGroupData = dupe.AgentData;
+//            ObjectDuplicatePacket.AgentDataBlock AgentandGroupData = dupe.AgentData;
 
             ObjectDuplicate handlerObjectDuplicate = null;
 
@@ -6297,8 +6770,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 if (handlerObjectDuplicate != null)
                 {
                     handlerObjectDuplicate(dupe.ObjectData[i].ObjectLocalID, dupe.SharedData.Offset,
-                                           dupe.SharedData.DuplicateFlags, AgentandGroupData.AgentID,
-                                           AgentandGroupData.GroupID);
+                                           dupe.SharedData.DuplicateFlags, AgentId,
+                                           m_activeGroupID);
                 }
             }
 
@@ -6888,7 +7361,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 if (handlerObjectDuplicateOnRay != null)
                 {
                     handlerObjectDuplicateOnRay(dupeOnRay.ObjectData[i].ObjectLocalID, dupeOnRay.AgentData.DuplicateFlags,
-                                                dupeOnRay.AgentData.AgentID, dupeOnRay.AgentData.GroupID, dupeOnRay.AgentData.RayTargetID, dupeOnRay.AgentData.RayEnd,
+                                                AgentId, m_activeGroupID, dupeOnRay.AgentData.RayTargetID, dupeOnRay.AgentData.RayEnd,
                                                 dupeOnRay.AgentData.RayStart, dupeOnRay.AgentData.BypassRaycast, dupeOnRay.AgentData.RayEndIsIntersection,
                                                 dupeOnRay.AgentData.CopyCenters, dupeOnRay.AgentData.CopyRotates);
                 }
@@ -7048,39 +7521,38 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             //handlerTextureRequest = null;
             for (int i = 0; i < imageRequest.RequestImage.Length; i++)
             {
-                if (OnRequestTexture != null)
-                {
-                    TextureRequestArgs args = new TextureRequestArgs();
-
-                    RequestImagePacket.RequestImageBlock block = imageRequest.RequestImage[i];
-
-                    args.RequestedAssetID = block.Image;
-                    args.DiscardLevel = block.DiscardLevel;
-                    args.PacketNumber = block.Packet;
-                    args.Priority = block.DownloadPriority;
-                    args.requestSequence = imageRequest.Header.Sequence;
+                TextureRequestArgs args = new TextureRequestArgs();
 
-                    // NOTE: This is not a built in part of the LLUDP protocol, but we double the
-                    // priority of avatar textures to get avatars rezzing in faster than the
-                    // surrounding scene
-                    if ((ImageType)block.Type == ImageType.Baked)
-                        args.Priority *= 2.0f;
+                RequestImagePacket.RequestImageBlock block = imageRequest.RequestImage[i];
 
-                    //handlerTextureRequest = OnRequestTexture;
+                args.RequestedAssetID = block.Image;
+                args.DiscardLevel = block.DiscardLevel;
+                args.PacketNumber = block.Packet;
+                args.Priority = block.DownloadPriority;
+                args.requestSequence = imageRequest.Header.Sequence;
 
-                    //if (handlerTextureRequest != null)
-                    //OnRequestTexture(this, args);
+                // NOTE: This is not a built in part of the LLUDP protocol, but we double the
+                // priority of avatar textures to get avatars rezzing in faster than the
+                // surrounding scene
+                if ((ImageType)block.Type == ImageType.Baked)
+                    args.Priority *= 2.0f;
 
-                    // in the end, we null this, so we have to check if it's null
-                    if (m_imageManager != null)
-                    {
-                        m_imageManager.EnqueueReq(args);
-                    }
+                // in the end, we null this, so we have to check if it's null
+                if (m_imageManager != null)
+                {
+                    m_imageManager.EnqueueReq(args);
                 }
             }
             return true;
         }
 
+        /// <summary>
+        /// This is the entry point for the UDP route by which the client can retrieve asset data.  If the request
+        /// is successful then a TransferInfo packet will be sent back, followed by one or more TransferPackets
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="Pack"></param>
+        /// <returns>This parameter may be ignored since we appear to return true whatever happens</returns>
         private bool HandleTransferRequest(IClientAPI sender, Packet Pack)
         {
             //m_log.Debug("ClientView.ProcessPackets.cs:ProcessInPacket() - Got transfer request");
@@ -7091,14 +7563,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // Has to be done here, because AssetCache can't do it
             //
             UUID taskID = UUID.Zero;
-            if (transfer.TransferInfo.SourceType == 3)
+            if (transfer.TransferInfo.SourceType == (int)SourceType.SimInventoryItem)
             {
                 taskID = new UUID(transfer.TransferInfo.Params, 48);
                 UUID itemID = new UUID(transfer.TransferInfo.Params, 64);
                 UUID requestID = new UUID(transfer.TransferInfo.Params, 80);
 
 //                m_log.DebugFormat(
-//                    "[CLIENT]: Got request for asset {0} from item {1} in prim {2} by {3}", 
+//                    "[CLIENT]: Got request for asset {0} from item {1} in prim {2} by {3}",
 //                    requestID, itemID, taskID, Name);
 
                 if (!(((Scene)m_scene).Permissions.BypassPermissions()))
@@ -7106,10 +7578,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     if (taskID != UUID.Zero) // Prim
                     {
                         SceneObjectPart part = ((Scene)m_scene).GetSceneObjectPart(taskID);
+
                         if (part == null)
                         {
                             m_log.WarnFormat(
-                                "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but prim does not exist", 
+                                "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but prim does not exist",
                                 Name, requestID, itemID, taskID);
                             return true;
                         }
@@ -7118,11 +7591,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         if (tii == null)
                         {
                             m_log.WarnFormat(
-                                "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but item does not exist", 
-                                Name, requestID, itemID, taskID);                            
+                                "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but item does not exist",
+                                Name, requestID, itemID, taskID);
                             return true;
-                        }                        
-                        
+                        }
+
                         if (tii.Type == (int)AssetType.LSLText)
                         {
                             if (!((Scene)m_scene).Permissions.CanEditScript(itemID, taskID, AgentId))
@@ -7136,103 +7609,68 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         else
                         {
                             // TODO: Change this code to allow items other than notecards and scripts to be successfully
-                            // shared with group.  In fact, all this permissions checking should move to an IPermissionsModule
+                            // shared with group.  In fact, this whole block of permissions checking should move to an IPermissionsModule
                             if (part.OwnerID != AgentId)
                             {
                                 m_log.WarnFormat(
                                     "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but the prim is owned by {4}",
-                                    Name, requestID, itemID, taskID, part.OwnerID);                            
+                                    Name, requestID, itemID, taskID, part.OwnerID);
                                 return true;
                             }
-    
+
                             if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
                             {
                                 m_log.WarnFormat(
-                                    "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but modify permissions are not set", 
-                                    Name, requestID, itemID, taskID);                            
+                                    "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but modify permissions are not set",
+                                    Name, requestID, itemID, taskID);
                                 return true;
                             }
-    
+
                             if (tii.OwnerID != AgentId)
                             {
                                 m_log.WarnFormat(
-                                    "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but the item is owned by {4}", 
-                                    Name, requestID, itemID, taskID, tii.OwnerID);                            
+                                    "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but the item is owned by {4}",
+                                    Name, requestID, itemID, taskID, tii.OwnerID);
                                 return true;
                             }
-    
+
                             if ((
-                                tii.CurrentPermissions & ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer)) 
+                                tii.CurrentPermissions & ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer))
                                     != ((uint)PermissionMask.Modify | (uint)PermissionMask.Copy | (uint)PermissionMask.Transfer))
                             {
                                 m_log.WarnFormat(
-                                    "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but item permissions are not modify/copy/transfer", 
-                                    Name, requestID, itemID, taskID);                            
+                                    "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but item permissions are not modify/copy/transfer",
+                                    Name, requestID, itemID, taskID);
                                 return true;
                             }
-    
+
                             if (tii.AssetID != requestID)
                             {
                                 m_log.WarnFormat(
-                                    "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but this does not match item's asset {4}", 
-                                    Name, requestID, itemID, taskID, tii.AssetID);                            
+                                    "[CLIENT]: {0} requested asset {1} from item {2} in prim {3} but this does not match item's asset {4}",
+                                    Name, requestID, itemID, taskID, tii.AssetID);
                                 return true;
                             }
                         }
                     }
                     else // Agent
                     {
-                        IInventoryService invService = m_scene.RequestModuleInterface<IInventoryService>();
-                        InventoryItemBase assetRequestItem = new InventoryItemBase(itemID, AgentId);
-                        assetRequestItem = invService.GetItem(assetRequestItem);
-                        if (assetRequestItem == null)
-                        {
-                            assetRequestItem = ((Scene)m_scene).CommsManager.UserProfileCacheService.LibraryRoot.FindItem(itemID);
-                            if (assetRequestItem == null)
-                                return true;
-                        }
-
-                        // At this point, we need to apply perms
-                        // only to notecards and scripts. All
-                        // other asset types are always available
-                        //
-                        if (assetRequestItem.AssetType == 10)
+                        IInventoryAccessModule invAccess = m_scene.RequestModuleInterface<IInventoryAccessModule>();
+                        if (invAccess != null)
                         {
-                            if (!((Scene)m_scene).Permissions.CanViewScript(itemID, UUID.Zero, AgentId))
-                            {
-                                SendAgentAlertMessage("Insufficient permissions to view script", false);
-                                return true;
-                            }
+                            if (!invAccess.CanGetAgentInventoryItem(this, itemID, requestID))
+                                return false;
                         }
-                        else if (assetRequestItem.AssetType == 7)
-                        {
-                            if (!((Scene)m_scene).Permissions.CanViewNotecard(itemID, UUID.Zero, AgentId))
-                            {
-                                SendAgentAlertMessage("Insufficient permissions to view notecard", false);
-                                return true;
-                            }
-                        }
-
-                        if (assetRequestItem.AssetID != requestID)
+                        else
                         {
-                            m_log.WarnFormat(
-                                "[CLIENT]: {0} requested asset {1} from item {2} but this does not match item's asset {3}", 
-                                Name, requestID, itemID, assetRequestItem.AssetID);                            
-                            return true;
+                            return false;
                         }
                     }
                 }
             }
 
-            //m_assetCache.AddAssetRequest(this, transfer);
-
             MakeAssetRequest(transfer, taskID);
 
-            /* RequestAsset = OnRequestAsset;
-                 if (RequestAsset != null)
-                 {
-                     RequestAsset(this, transfer);
-                 }*/
             return true;
         }
 
@@ -7240,7 +7678,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack;
 
-
             // m_log.Debug("upload request " + request.ToString());
             // m_log.Debug("upload request was for assetid: " + request.AssetBlock.TransactionID.Combine(this.SecureSessionId).ToString());
             UUID temp = UUID.Combine(request.AssetBlock.TransactionID, SecureSessionId);
@@ -7422,6 +7859,38 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return true;
         }
 
+        private bool HandleLinkInventoryItem(IClientAPI sender, Packet Pack)
+        {
+            LinkInventoryItemPacket createLink = (LinkInventoryItemPacket)Pack;
+
+            #region Packet Session and User Check
+            if (m_checkPackets)
+            {
+                if (createLink.AgentData.SessionID != SessionId ||
+                    createLink.AgentData.AgentID != AgentId)
+                    return true;
+            }
+            #endregion
+
+            LinkInventoryItem linkInventoryItem = OnLinkInventoryItem;
+
+            if (linkInventoryItem != null)
+            {
+                linkInventoryItem(
+                    this,
+                    createLink.InventoryBlock.TransactionID,
+                    createLink.InventoryBlock.FolderID,
+                    createLink.InventoryBlock.CallbackID,
+                    Util.FieldToString(createLink.InventoryBlock.Description),
+                    Util.FieldToString(createLink.InventoryBlock.Name),
+                    createLink.InventoryBlock.InvType,
+                    createLink.InventoryBlock.Type,
+                    createLink.InventoryBlock.OldItemID);
+            }
+
+            return true;
+        }
+
         private bool HandleFetchInventory(IClientAPI sender, Packet Pack)
         {
             if (OnFetchInventory != null)
@@ -7782,7 +8251,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                                    newTaskItem, updatetask.UpdateData.LocalID);
                     }
                 }
-            }               
+            }
 
             return true;
         }
@@ -7919,13 +8388,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     return true;
             }
             #endregion
-
             string mapName = Util.UTF8.GetString(map.NameData.Name, 0,
                                                      map.NameData.Name.Length - 1);
             RequestMapName handlerMapNameRequest = OnMapNameRequest;
             if (handlerMapNameRequest != null)
             {
-                handlerMapNameRequest(this, mapName);
+                handlerMapNameRequest(this, mapName, map.AgentData.Flags);
             }
             return true;
         }
@@ -7947,16 +8415,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AssetLandmark lm;
             if (lmid != UUID.Zero)
             {
+
                 //AssetBase lma = m_assetCache.GetAsset(lmid, false);
                 AssetBase lma = m_assetService.Get(lmid.ToString());
 
                 if (lma == null)
                 {
                     // Failed to find landmark
-                    TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
-                    tpCancel.Info.SessionID = tpReq.Info.SessionID;
-                    tpCancel.Info.AgentID = tpReq.Info.AgentID;
-                    OutPacket(tpCancel, ThrottleOutPacketType.Task);
+
+                    // Let's try to search in the user's home asset server
+                    lma = FindAssetInUserAssetServer(lmid.ToString());
+
+                    if (lma == null)
+                    {
+                        // Really doesn't exist
+                        TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
+                        tpCancel.Info.SessionID = tpReq.Info.SessionID;
+                        tpCancel.Info.AgentID = tpReq.Info.AgentID;
+                        OutPacket(tpCancel, ThrottleOutPacketType.Task);
+                    }
                 }
 
                 try
@@ -7987,13 +8464,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             TeleportLandmarkRequest handlerTeleportLandmarkRequest = OnTeleportLandmarkRequest;
             if (handlerTeleportLandmarkRequest != null)
             {
-                handlerTeleportLandmarkRequest(this, lm.RegionID, lm.Position);
+                handlerTeleportLandmarkRequest(this, lm);
             }
             else
             {
                 //no event handler so cancel request
-
-
                 TeleportCancelPacket tpCancel = (TeleportCancelPacket)PacketPool.Instance.GetPacket(PacketType.TeleportCancel);
                 tpCancel.Info.AgentID = tpReq.Info.AgentID;
                 tpCancel.Info.SessionID = tpReq.Info.SessionID;
@@ -8003,6 +8478,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return true;
         }
 
+        private AssetBase FindAssetInUserAssetServer(string id)
+        {
+            AgentCircuitData aCircuit = ((Scene)Scene).AuthenticateHandler.GetAgentCircuitData(CircuitCode);
+            if (aCircuit != null && aCircuit.ServiceURLs != null && aCircuit.ServiceURLs.ContainsKey("AssetServerURI"))
+            {
+                string assetServer = aCircuit.ServiceURLs["AssetServerURI"].ToString();
+                return ((Scene)Scene).AssetService.Get(assetServer + "/" + id);
+            }
+
+            return null;
+        }
+
         private bool HandleTeleportLocationRequest(IClientAPI sender, Packet Pack)
         {
             TeleportLocationRequestPacket tpLocReq = (TeleportLocationRequestPacket)Pack;
@@ -8129,7 +8616,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
                 entry.AgentID = block.ID;
                 entry.Flags = (AccessList)block.Flags;
-                entry.Time = new DateTime();
+                entry.Time = Util.ToDateTime(block.Time);
                 entries.Add(entry);
             }
 
@@ -8137,8 +8624,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (handlerParcelAccessListUpdateRequest != null)
             {
                 handlerParcelAccessListUpdateRequest(updatePacket.AgentData.AgentID,
-                                                     updatePacket.AgentData.SessionID, updatePacket.Data.Flags,
-                                                     updatePacket.Data.LocalID, entries, this);
+                                                     updatePacket.Data.Flags,
+                                                     updatePacket.Data.LocalID,
+                                                     updatePacket.Data.TransactionID,
+                                                     updatePacket.Data.SequenceID,
+                                                     updatePacket.Data.Sections,
+                                                     entries, this);
             }
             return true;
         }
@@ -8649,13 +9140,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 case "instantmessage":
                     if (((Scene)m_scene).Permissions.CanIssueEstateCommand(AgentId, false))
                     {
-                        if (messagePacket.ParamList.Length < 5)
+                        if (messagePacket.ParamList.Length < 2)
                             return true;
+
                         UUID invoice = messagePacket.MethodData.Invoice;
-                        UUID SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
-                        string SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);
-                        string Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);
                         UUID sessionID = messagePacket.AgentData.SessionID;
+
+                        UUID SenderID;
+                        string SenderName;
+                        string Message;
+
+                        if (messagePacket.ParamList.Length < 5)
+                        {
+                            SenderID = AgentId;
+                            SenderName = Utils.BytesToString(messagePacket.ParamList[0].Parameter);
+                            Message = Utils.BytesToString(messagePacket.ParamList[1].Parameter);
+                        }
+                        else
+                        { 
+                            SenderID = new UUID(Utils.BytesToString(messagePacket.ParamList[2].Parameter));
+                            SenderName = Utils.BytesToString(messagePacket.ParamList[3].Parameter);
+                            Message = Utils.BytesToString(messagePacket.ParamList[4].Parameter);
+                        }
+
                         OnEstateBlueBoxMessageRequest(this, invoice, SenderID, sessionID, SenderName, Message);
                     }
                     return true;
@@ -8777,7 +9284,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
 //            return true;
         }
-        
+
         private bool HandleRequestRegionInfo(IClientAPI sender, Packet Pack)
         {
             RequestRegionInfoPacket.AgentDataBlock mPacket = ((RequestRegionInfoPacket)Pack).AgentData;
@@ -8798,7 +9305,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return true;
         }
-        
+
         private bool HandleEstateCovenantRequest(IClientAPI sender, Packet Pack)
         {
 
@@ -8835,7 +9342,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             return true;
         }
-        
+
         private bool HandleGodUpdateRegionInfoUpdate(IClientAPI client, Packet Packet)
         {
             GodUpdateRegionInfoPacket GodUpdateRegionInfo =
@@ -8855,7 +9362,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleSimWideDeletes(IClientAPI client, Packet Packet)
         {
             SimWideDeletesPacket SimWideDeletesRequest =
@@ -8868,7 +9375,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleGodlikeMessage(IClientAPI client, Packet Packet)
         {
             GodlikeMessagePacket GodlikeMessage =
@@ -8885,7 +9392,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleSaveStatePacket(IClientAPI client, Packet Packet)
         {
             StateSavePacket SaveStateMessage =
@@ -8898,7 +9405,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleGodKickUser(IClientAPI sender, Packet Pack)
         {
             GodKickUserPacket gkupack = (GodKickUserPacket)Pack;
@@ -8909,7 +9416,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 if (handlerGodKickUser != null)
                 {
                     handlerGodKickUser(gkupack.UserInfo.GodID, gkupack.UserInfo.GodSessionID,
-                                       gkupack.UserInfo.AgentID, (uint)0, gkupack.UserInfo.Reason);
+                                       gkupack.UserInfo.AgentID, gkupack.UserInfo.KickFlags, gkupack.UserInfo.Reason);
                 }
             }
             else
@@ -9036,7 +9543,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return true;
         }
-        
+
         #endregion Economy/Transaction Packets
 
         #region Script Packets
@@ -9249,7 +9756,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return true;
         }
-        
+
         private bool HandleUpdateMuteListEntry(IClientAPI client, Packet Packet)
         {
             UpdateMuteListEntryPacket UpdateMuteListEntry =
@@ -9260,12 +9767,12 @@ 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;
         }
-        
+
         private bool HandleRemoveMuteListEntry(IClientAPI client, Packet Packet)
         {
             RemoveMuteListEntryPacket RemoveMuteListEntry =
@@ -9275,13 +9782,12 @@ 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;
         }
-        
+
         private bool HandleUserReport(IClientAPI client, Packet Packet)
         {
             UserReportPacket UserReport =
@@ -9306,7 +9812,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleSendPostcard(IClientAPI client, Packet packet)
         {
 //            SendPostcardPacket SendPostcard =
@@ -9320,10 +9826,55 @@ 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)
         {
@@ -9588,7 +10139,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return true;
 
         }
-        
+
         private bool HandleGroupVoteHistoryRequest(IClientAPI client, Packet Packet)
         {
             GroupVoteHistoryRequestPacket GroupVoteHistoryRequest =
@@ -9601,7 +10152,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleGroupActiveProposalsRequest(IClientAPI client, Packet Packet)
         {
             GroupActiveProposalsRequestPacket GroupActiveProposalsRequest =
@@ -9614,7 +10165,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleGroupAccountDetailsRequest(IClientAPI client, Packet Packet)
         {
             GroupAccountDetailsRequestPacket GroupAccountDetailsRequest =
@@ -9627,7 +10178,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleGroupAccountSummaryRequest(IClientAPI client, Packet Packet)
         {
             GroupAccountSummaryRequestPacket GroupAccountSummaryRequest =
@@ -9640,7 +10191,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleGroupTransactionsDetailsRequest(IClientAPI client, Packet Packet)
         {
             GroupAccountTransactionsRequestPacket GroupAccountTransactionsRequest =
@@ -9653,7 +10204,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             return false;
         }
-        
+
         private bool HandleGroupTitlesRequest(IClientAPI sender, Packet Pack)
         {
             GroupTitlesRequestPacket groupTitlesRequest =
@@ -9750,6 +10301,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 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.GodLevel >= 200)
+                        {
+                            groupProfileReply.GroupData.OpenEnrollment = true;
+                            groupProfileReply.GroupData.MembershipFee = 0;
+                        }
+                    }
+                }
+
                 OutPacket(groupProfileReply, ThrottleOutPacketType.Task);
             }
             return true;
@@ -10322,11 +10887,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)
@@ -10440,10 +11010,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;
         }
@@ -10644,6 +11215,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     Utils.BytesToString(avatarInterestUpdate.PropertiesData.LanguagesText));
             return true;
         }
+
         private bool HandleGrantUserRights(IClientAPI sender, Packet Pack)
         {
             GrantUserRightsPacket GrantUserRights =
@@ -10664,6 +11236,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     GrantUserRights.Rights[0].RelatedRights);
             return true;
         }
+
         private bool HandlePlacesQuery(IClientAPI sender, Packet Pack)
         {
             PlacesQueryPacket placesQueryPacket =
@@ -10803,8 +11376,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         protected bool HandleMultipleObjUpdate(IClientAPI simClient, Packet packet)
         {
             MultipleObjectUpdatePacket multipleupdate = (MultipleObjectUpdatePacket)packet;
-            if (multipleupdate.AgentData.SessionID != SessionId) return false;
-            // m_log.Debug("new multi update packet " + multipleupdate.ToString());
+
+            if (multipleupdate.AgentData.SessionID != SessionId)
+                return false;
+
+//            m_log.DebugFormat(
+//                "[CLIENT]: Incoming MultipleObjectUpdatePacket contained {0} blocks", multipleupdate.ObjectData.Length);
+
             Scene tScene = (Scene)m_scene;
 
             for (int i = 0; i < multipleupdate.ObjectData.Length; i++)
@@ -10821,11 +11399,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     {
                         // It's a ghost! tell the client to delete it from view.
                         simClient.SendKillObject(Scene.RegionInfo.RegionHandle,
-                                                 localId);
+                                                 new List<uint> { localId });
                     }
                     else
                     {
-                        // UUID partId = part.UUID;
+//                        m_log.DebugFormat(
+//                            "[CLIENT]: Processing block {0} type {1} for {2} {3}",
+//                            i, block.Type, part.Name, part.LocalId);
+
+//                        // 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;
+//                        }
+
                         UpdatePrimGroupRotation handlerUpdatePrimGroupRotation;
 
                         switch (block.Type)
@@ -10840,6 +11429,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     handlerUpdatePrimSinglePosition(localId, pos1, this);
                                 }
                                 break;
+
                             case 2:
                                 Quaternion rot1 = new Quaternion(block.Data, 0, true);
 
@@ -10850,6 +11440,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     handlerUpdatePrimSingleRotation(localId, rot1, this);
                                 }
                                 break;
+
                             case 3:
                                 Vector3 rotPos = new Vector3(block.Data, 0);
                                 Quaternion rot2 = new Quaternion(block.Data, 12, true);
@@ -10862,6 +11453,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     handlerUpdatePrimSingleRotationPosition(localId, rot2, rotPos, this);
                                 }
                                 break;
+
                             case 4:
                             case 20:
                                 Vector3 scale4 = new Vector3(block.Data, 0);
@@ -10873,8 +11465,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     handlerUpdatePrimScale(localId, scale4, this);
                                 }
                                 break;
-                            case 5:
 
+                            case 5:
                                 Vector3 scale1 = new Vector3(block.Data, 12);
                                 Vector3 pos11 = new Vector3(block.Data, 0);
 
@@ -10891,6 +11483,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     }
                                 }
                                 break;
+
                             case 9:
                                 Vector3 pos2 = new Vector3(block.Data, 0);
 
@@ -10898,10 +11491,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                                 if (handlerUpdateVector != null)
                                 {
-
                                     handlerUpdateVector(localId, pos2, this);
                                 }
                                 break;
+
                             case 10:
                                 Quaternion rot3 = new Quaternion(block.Data, 0, true);
 
@@ -10912,6 +11505,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     handlerUpdatePrimRotation(localId, rot3, this);
                                 }
                                 break;
+
                             case 11:
                                 Vector3 pos3 = new Vector3(block.Data, 0);
                                 Quaternion rot4 = new Quaternion(block.Data, 12, true);
@@ -10935,6 +11529,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     handlerUpdatePrimGroupScale(localId, scale7, this);
                                 }
                                 break;
+
                             case 13:
                                 Vector3 scale2 = new Vector3(block.Data, 12);
                                 Vector3 pos4 = new Vector3(block.Data, 0);
@@ -10954,6 +11549,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     }
                                 }
                                 break;
+
                             case 29:
                                 Vector3 scale5 = new Vector3(block.Data, 12);
                                 Vector3 pos5 = new Vector3(block.Data, 0);
@@ -10962,6 +11558,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                 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;
 
@@ -10969,8 +11567,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     {
                                         handlerUpdateVector(localId, pos5, this);
                                     }
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
+
                                 break;
+
                             case 21:
                                 Vector3 scale6 = new Vector3(block.Data, 12);
                                 Vector3 pos6 = new Vector3(block.Data, 0);
@@ -10978,6 +11580,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                 handlerUpdatePrimScale = OnUpdatePrimScale;
                                 if (handlerUpdatePrimScale != null)
                                 {
+                                    part.StoreUndoState(false);
+                                    part.IgnoreUndoUpdate = true;
+
                                     // m_log.Debug("new scale is " + scale.X + " , " + scale.Y + " , " + scale.Z);
                                     handlerUpdatePrimScale(localId, scale6, this);
                                     handlerUpdatePrimSinglePosition = OnUpdatePrimSinglePosition;
@@ -10985,15 +11590,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     {
                                         handlerUpdatePrimSinglePosition(localId, pos6, this);
                                     }
+
+                                    part.IgnoreUndoUpdate = false;
                                 }
                                 break;
+
                             default:
-                                m_log.Debug("[CLIENT] MultipleObjUpdate recieved an unknown packet type: " + (block.Type));
+                                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;
         }
 
@@ -11063,7 +11675,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <returns></returns>
         public byte[] GetThrottlesPacked(float multiplier)
         {
-            return m_udpClient.GetThrottlesPacked();
+            return m_udpClient.GetThrottlesPacked(multiplier);
         }
 
         /// <summary>
@@ -11098,10 +11710,50 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// handles splitting manually</param>
         protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType, bool doAutomaticSplitting)
         {
-            if (m_debugPacketLevel >= 255)
-                m_log.DebugFormat("[CLIENT]: Packet OUT {0}", packet.Type);
+            OutPacket(packet, throttlePacketType, doAutomaticSplitting, null);
+        }
+
+        /// <summary>
+        /// This is the starting point for sending a simulator packet out to the client
+        /// </summary>
+        /// <param name="packet">Packet to send</param>
+        /// <param name="throttlePacketType">Throttling category for the packet</param>
+        /// <param name="doAutomaticSplitting">True to automatically split oversized
+        /// packets (the default), or false to disable splitting if the calling code
+        /// handles splitting manually</param>
+        /// <param name="method">The method to be called in the event this packet is reliable
+        /// and unacknowledged. The server will provide normal resend capability if you do not
+        /// provide your own method.</param>
+        protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType, bool doAutomaticSplitting, UnackedPacketMethod method)
+        {
+            if (DebugPacketLevel > 0)
+            {
+                bool logPacket = true;
+
+                if (DebugPacketLevel <= 255
+                    && (packet.Type == PacketType.SimStats || packet.Type == PacketType.SimulatorViewerTimeMessage))
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 200
+                    && (packet.Type == PacketType.ImagePacket
+                        || packet.Type == PacketType.ImageData
+                        || packet.Type == PacketType.LayerData
+                        || packet.Type == PacketType.CoarseLocationUpdate))
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 100 && (packet.Type == PacketType.AvatarAnimation || packet.Type == PacketType.ViewerEffect))
+                    logPacket = false;
+                
+                if (DebugPacketLevel <= 50 && packet.Type == PacketType.ImprovedTerseObjectUpdate)
+                    logPacket = false;
+
+                if (logPacket)
+                    m_log.DebugFormat(
+                        "[CLIENT]: PACKET OUT to   {0} ({1}) in {2} - {3}",
+                        Name, ChildAgentStatus() ? "child" : "root ", m_scene.RegionInfo.RegionName, packet.Type);
+            }
             
-            m_udpServer.SendPacket(m_udpClient, packet, throttlePacketType, doAutomaticSplitting);
+            m_udpServer.SendPacket(m_udpClient, packet, throttlePacketType, doAutomaticSplitting, method);
         }
 
         public bool AddMoney(int debit)
@@ -11115,70 +11767,53 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return false;
         }
 
-        /// <summary>
-        /// Breaks down the genericMessagePacket into specific events
-        /// </summary>
-        /// <param name="gmMethod"></param>
-        /// <param name="gmInvoice"></param>
-        /// <param name="gmParams"></param>
-        public void DecipherGenericMessage(string gmMethod, UUID gmInvoice, GenericMessagePacket.ParamListBlock[] gmParams)
+        protected void HandleAutopilot(Object sender, string method, List<String> args)
         {
-            switch (gmMethod)
-            {
-                case "autopilot":
-                    float locx;
-                    float locy;
-                    float locz;
+            float locx = 0;
+            float locy = 0;
+            float locz = 0;
+            uint regionX = 0;
+            uint regionY = 0;
 
-                    try
-                    {
-                        uint regionX;
-                        uint regionY;
-                        Utils.LongToUInts(Scene.RegionInfo.RegionHandle, out regionX, out regionY);
-                        locx = Convert.ToSingle(Utils.BytesToString(gmParams[0].Parameter)) - regionX;
-                        locy = Convert.ToSingle(Utils.BytesToString(gmParams[1].Parameter)) - regionY;
-                        locz = Convert.ToSingle(Utils.BytesToString(gmParams[2].Parameter));
-                    }
-                    catch (InvalidCastException)
-                    {
-                        m_log.Error("[CLIENT]: Invalid autopilot request");
-                        return;
-                    }
-
-                    UpdateVector handlerAutoPilotGo = OnAutoPilotGo;
-                    if (handlerAutoPilotGo != null)
-                    {
-                        handlerAutoPilotGo(0, new Vector3(locx, locy, locz), this);
-                    }
-                    m_log.InfoFormat("[CLIENT]: Client Requests autopilot to position <{0},{1},{2}>", locx, locy, locz);
-
-
-                    break;
-                default:
-                    m_log.Debug("[CLIENT]: Unknown Generic Message, Method: " + gmMethod + ". Invoice: " + gmInvoice + ".  Dumping Params:");
-                    for (int hi = 0; hi < gmParams.Length; hi++)
-                    {
-                        Console.WriteLine(gmParams[hi].ToString());
-                    }
-                    //gmpack.MethodData.
-                    break;
+            Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out regionX, out regionY);
+            locx = Convert.ToSingle(args[0]) - (float)regionX;
+            locy = Convert.ToSingle(args[1]) - (float)regionY;
+            locz = Convert.ToSingle(args[2]);
 
-            }
+            Action<Vector3, bool, bool> handlerAutoPilotGo = OnAutoPilotGo;
+            if (handlerAutoPilotGo != null)
+                handlerAutoPilotGo(new Vector3(locx, locy, locz), false, false);
         }
 
         /// <summary>
         /// Entryway from the client to the simulator.  All UDP packets from the client will end up here
         /// </summary>
         /// <param name="Pack">OpenMetaverse.packet</param>
-        public void ProcessInPacket(Packet Pack)
+        public void ProcessInPacket(Packet packet)
         {
-            if (m_debugPacketLevel >= 255)
-                m_log.DebugFormat("[CLIENT]: Packet IN {0}", Pack.Type);
-            
-            if (!ProcessPacketMethod(Pack))
-                m_log.Warn("[CLIENT]: unhandled packet " + Pack.Type);
+            if (DebugPacketLevel > 0)
+            {
+                bool logPacket = true;
 
-            PacketPool.Instance.ReturnPacket(Pack);
+                if (DebugPacketLevel <= 255 && packet.Type == PacketType.AgentUpdate)
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 200 && packet.Type == PacketType.RequestImage)
+                    logPacket = false;
+
+                if (DebugPacketLevel <= 100 && (packet.Type == PacketType.ViewerEffect || packet.Type == PacketType.AgentAnimation))
+                    logPacket = false;
+
+                if (logPacket)
+                    m_log.DebugFormat(
+                        "[CLIENT]: PACKET IN  from {0} ({1}) in {2} - {3}",
+                        Name, ChildAgentStatus() ? "child" : "root ", m_scene.RegionInfo.RegionName, packet.Type);
+            }
+
+            if (!ProcessPacketMethod(packet))
+                m_log.Warn("[CLIENT]: unhandled packet " + packet.Type);
+
+            PacketPool.Instance.ReturnPacket(packet);
         }
 
         private static PrimitiveBaseShape GetShapeFromAddPacket(ObjectAddPacket addPacket)
@@ -11218,7 +11853,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             info.userEP = m_userEndPoint;
             info.proxyEP = null;
-            info.agentcircuit = new sAgentCircuitData(RequestClientInfo());
+            info.agentcircuit = RequestClientInfo();
 
             return info;
         }
@@ -11396,81 +12031,60 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return String.Empty;
         }
 
-        public void MakeAssetRequest(TransferRequestPacket transferRequest, UUID taskID)
+        /// <summary>
+        /// Make an asset request to the asset service in response to a client request.
+        /// </summary>
+        /// <param name="transferRequest"></param>
+        /// <param name="taskID"></param>
+        protected void MakeAssetRequest(TransferRequestPacket transferRequest, UUID taskID)
         {
             UUID requestID = UUID.Zero;
-            if (transferRequest.TransferInfo.SourceType == 2)
+            if (transferRequest.TransferInfo.SourceType == (int)SourceType.Asset)
             {
-                //direct asset request
                 requestID = new UUID(transferRequest.TransferInfo.Params, 0);
             }
-            else if (transferRequest.TransferInfo.SourceType == 3)
+            else if (transferRequest.TransferInfo.SourceType == (int)SourceType.SimInventoryItem)
             {
-                //inventory asset request
                 requestID = new UUID(transferRequest.TransferInfo.Params, 80);
-                //m_log.Debug("[XXX] inventory asset request " + requestID);
-                //if (taskID == UUID.Zero) // Agent
-                //    if (m_scene is HGScene)
-                //    {
-                //        m_log.Debug("[XXX] hg asset request " + requestID);
-                //        // We may need to fetch the asset from the user's asset server into the local asset server
-                //        HGAssetMapper mapper = ((HGScene)m_scene).AssetMapper;
-                //        mapper.Get(requestID, AgentId);
-                //    }
             }
 
 //            m_log.DebugFormat("[CLIENT]: {0} requesting asset {1}", Name, requestID);
 
+
+            //Note, the bool returned from the below function is useless since it is always false.
             m_assetService.Get(requestID.ToString(), transferRequest, AssetReceived);
 
         }
 
+        /// <summary>
+        /// When we get a reply back from the asset service in response to a client request, send back the data.
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="sender"></param>
+        /// <param name="asset"></param>
         protected void AssetReceived(string id, Object sender, AssetBase asset)
         {
+            if (asset == null)
+                return;
+
             TransferRequestPacket transferRequest = (TransferRequestPacket)sender;
 
             UUID requestID = UUID.Zero;
-            byte source = 2;
-            if ((transferRequest.TransferInfo.SourceType == 2) || (transferRequest.TransferInfo.SourceType == 2222))
+            byte source = (byte)SourceType.Asset;
+
+            if (transferRequest.TransferInfo.SourceType == (int)SourceType.Asset)
             {
-                //direct asset request
                 requestID = new UUID(transferRequest.TransferInfo.Params, 0);
             }
-            else if ((transferRequest.TransferInfo.SourceType == 3) || (transferRequest.TransferInfo.SourceType == 3333))
+            else if (transferRequest.TransferInfo.SourceType == (int)SourceType.SimInventoryItem)
             {
-                //inventory asset request
                 requestID = new UUID(transferRequest.TransferInfo.Params, 80);
-                source = 3;
+                source = (byte)SourceType.SimInventoryItem;
                 //m_log.Debug("asset request " + requestID);
             }
 
-            if (null == asset)
-            {
-                if ((m_hyperAssets != null) && (transferRequest.TransferInfo.SourceType < 2000))
-                {
-                    // Try the user's inventory, but only if it's different from the regions'
-                    string userAssets = m_hyperAssets.GetUserAssetServer(AgentId);
-                    if ((userAssets != string.Empty) && (userAssets != m_hyperAssets.GetSimAssetServer()))
-                    {
-                        m_log.DebugFormat("[CLIENT]: asset {0} not found in local asset storage. Trying user's storage.", id);
-                        if (transferRequest.TransferInfo.SourceType == 2)
-                            transferRequest.TransferInfo.SourceType = 2222; // marker
-                        else if (transferRequest.TransferInfo.SourceType == 3)
-                            transferRequest.TransferInfo.SourceType = 3333; // marker
-
-                        m_assetService.Get(userAssets + "/" + id, transferRequest, AssetReceived);
-                        return;
-                    }
-                }
-
-                //m_log.DebugFormat("[ASSET CACHE]: Asset transfer request for asset which is {0} already known to be missing.  Dropping", requestID);
-
-                // FIXME: We never tell the client about assets which do not exist when requested by this transfer mechanism, which can't be right.
-                return;
-            }
-
             // Scripts cannot be retrieved by direct request
-            if (transferRequest.TransferInfo.SourceType == 2 && asset.Type == 10)
+            if (transferRequest.TransferInfo.SourceType == (int)SourceType.Asset && asset.Type == 10)
                 return;
 
             // The asset is known to exist and is in our cache, so add it to the AssetRequests list
@@ -11496,6 +12110,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             const uint m_maxPacketSize = 600;
             int numPackets = 1;
 
+            if (data == null)
+                return 0;
+
             if (data.LongLength > m_maxPacketSize)
             {
                 // over max number of bytes so split up file
@@ -11535,172 +12152,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(pack, ThrottleOutPacketType.Task);
         }
 
-        #region PriorityQueue
-        public class PriorityQueue<TPriority, TValue>
-        {
-            internal delegate bool UpdatePriorityHandler(ref TPriority priority, uint local_id);
-
-            private MinHeap<MinHeapItem>[] m_heaps = new MinHeap<MinHeapItem>[1];
-            private Dictionary<uint, LookupItem> m_lookupTable;
-            private Comparison<TPriority> m_comparison;
-            private object m_syncRoot = new object();
-
-            internal PriorityQueue() :
-                this(MinHeap<MinHeapItem>.DEFAULT_CAPACITY, Comparer<TPriority>.Default) { }
-            internal PriorityQueue(int capacity) :
-                this(capacity, Comparer<TPriority>.Default) { }
-            internal PriorityQueue(IComparer<TPriority> comparer) :
-                this(new Comparison<TPriority>(comparer.Compare)) { }
-            internal PriorityQueue(Comparison<TPriority> comparison) :
-                this(MinHeap<MinHeapItem>.DEFAULT_CAPACITY, comparison) { }
-            internal PriorityQueue(int capacity, IComparer<TPriority> comparer) :
-                this(capacity, new Comparison<TPriority>(comparer.Compare)) { }
-            internal PriorityQueue(int capacity, Comparison<TPriority> comparison)
-            {
-                m_lookupTable = new Dictionary<uint, LookupItem>(capacity);
-
-                for (int i = 0; i < m_heaps.Length; ++i)
-                    m_heaps[i] = new MinHeap<MinHeapItem>(capacity);
-                this.m_comparison = comparison;
-            }
-
-            public object SyncRoot { get { return this.m_syncRoot; } }
-            internal int Count
-            {
-                get
-                {
-                    int count = 0;
-                    for (int i = 0; i < m_heaps.Length; ++i)
-                        count = m_heaps[i].Count;
-                    return count;
-                }
-            }
-
-            public bool Enqueue(TPriority priority, TValue value, uint local_id)
-            {
-                LookupItem item;
-
-                if (m_lookupTable.TryGetValue(local_id, out item))
-                {
-                    item.Heap[item.Handle] = new MinHeapItem(priority, value, local_id, this.m_comparison);
-                    return false;
-                }
-                else
-                {
-                    item.Heap = m_heaps[0];
-                    item.Heap.Add(new MinHeapItem(priority, value, local_id, this.m_comparison), ref item.Handle);
-                    m_lookupTable.Add(local_id, item);
-                    return true;
-                }
-            }
-
-            internal TValue Peek()
-            {
-                for (int i = 0; i < m_heaps.Length; ++i)
-                    if (m_heaps[i].Count > 0)
-                        return m_heaps[i].Min().Value;
-                throw new InvalidOperationException(string.Format("The {0} is empty", this.GetType().ToString()));
-            }
-
-            internal TValue Dequeue()
-            {
-                for (int i = 0; i < m_heaps.Length; ++i)
-                {
-                    if (m_heaps[i].Count > 0)
-                    {
-                        MinHeapItem item = m_heaps[i].RemoveMin();
-                        m_lookupTable.Remove(item.LocalID);
-                        return item.Value;
-                    }
-                }
-                throw new InvalidOperationException(string.Format("The {0} is empty", this.GetType().ToString()));
-            }
-
-            internal void Reprioritize(UpdatePriorityHandler handler)
-            {
-                MinHeapItem item;
-                TPriority priority;
-
-                foreach (LookupItem lookup in new List<LookupItem>(this.m_lookupTable.Values))
-                {
-                    if (lookup.Heap.TryGetValue(lookup.Handle, out item))
-                    {
-                        priority = item.Priority;
-                        if (handler(ref priority, item.LocalID))
-                        {
-                            if (lookup.Heap.ContainsHandle(lookup.Handle))
-                                lookup.Heap[lookup.Handle] =
-                                    new MinHeapItem(priority, item.Value, item.LocalID, this.m_comparison);
-                        }
-                        else
-                        {
-                            m_log.Warn("[LLCLIENTVIEW]: UpdatePriorityHandler returned false, dropping update");
-                            lookup.Heap.Remove(lookup.Handle);
-                            this.m_lookupTable.Remove(item.LocalID);
-                        }
-                    }
-                }
-            }
-
-            #region MinHeapItem
-            private struct MinHeapItem : IComparable<MinHeapItem>
-            {
-                private TPriority priority;
-                private TValue value;
-                private uint local_id;
-                private Comparison<TPriority> comparison;
-
-                internal MinHeapItem(TPriority priority, TValue value, uint local_id) :
-                    this(priority, value, local_id, Comparer<TPriority>.Default) { }
-                internal MinHeapItem(TPriority priority, TValue value, uint local_id, IComparer<TPriority> comparer) :
-                    this(priority, value, local_id, new Comparison<TPriority>(comparer.Compare)) { }
-                internal MinHeapItem(TPriority priority, TValue value, uint local_id, Comparison<TPriority> comparison)
-                {
-                    this.priority = priority;
-                    this.value = value;
-                    this.local_id = local_id;
-                    this.comparison = comparison;
-                }
-
-                internal TPriority Priority { get { return this.priority; } }
-                internal TValue Value { get { return this.value; } }
-                internal uint LocalID { get { return this.local_id; } }
-
-                public override string ToString()
-                {
-                    StringBuilder sb = new StringBuilder();
-                    sb.Append("[");
-                    if (this.priority != null)
-                        sb.Append(this.priority.ToString());
-                    sb.Append(",");
-                    if (this.value != null)
-                        sb.Append(this.value.ToString());
-                    sb.Append("]");
-                    return sb.ToString();
-                }
-
-                public int CompareTo(MinHeapItem other)
-                {
-                    return this.comparison(this.priority, other.priority);
-                }
-            }
-            #endregion
-
-            #region LookupItem
-            private struct LookupItem
-            {
-                internal MinHeap<MinHeapItem> Heap;
-                internal IHandle Handle;
-            }
-            #endregion
-        }
-
         public struct PacketProcessor
         {
             public PacketMethod method;
             public bool Async;
         }
-        
+
         public class AsyncPacketProcess
         {
             public bool result = false;
@@ -11715,8 +12172,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
 
-        #endregion
-
         public static OSD BuildEvent(string eventName, OSD eventBody)
         {
             OSDMap osdEvent = new OSDMap(2);
@@ -11742,5 +12197,153 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             packet.PropertiesData.LanguagesText = Utils.StringToBytes(languages);
             OutPacket(packet, ThrottleOutPacketType.Task);
         }
+
+        public void SendChangeUserRights(UUID agentID, UUID friendID, int rights)
+        {
+            ChangeUserRightsPacket packet = (ChangeUserRightsPacket)PacketPool.Instance.GetPacket(PacketType.ChangeUserRights);
+
+            packet.AgentData = new ChangeUserRightsPacket.AgentDataBlock();
+            packet.AgentData.AgentID = agentID;
+
+            packet.Rights = new ChangeUserRightsPacket.RightsBlock[1];
+            packet.Rights[0] = new ChangeUserRightsPacket.RightsBlock();
+            packet.Rights[0].AgentRelated = friendID;
+            packet.Rights[0].RelatedRights = rights;
+
+            OutPacket(packet, ThrottleOutPacketType.Task);
+        }
+
+        public void SendTextBoxRequest(string message, int chatChannel, string objectname, UUID ownerID, string ownerFirstName, string ownerLastName, UUID objectId)
+        {
+            ScriptDialogPacket dialog = (ScriptDialogPacket)PacketPool.Instance.GetPacket(PacketType.ScriptDialog);
+            dialog.Data.ObjectID = objectId;
+            dialog.Data.ChatChannel = chatChannel;
+            dialog.Data.ImageID = UUID.Zero;
+            dialog.Data.ObjectName = Util.StringToBytes256(objectname);
+            // this is the username of the *owner*
+            dialog.Data.FirstName = Util.StringToBytes256(ownerFirstName);
+            dialog.Data.LastName = Util.StringToBytes256(ownerLastName);
+            dialog.Data.Message =  Util.StringToBytes256(message);
+
+            ScriptDialogPacket.ButtonsBlock[] buttons = new ScriptDialogPacket.ButtonsBlock[1];
+            buttons[0] = new ScriptDialogPacket.ButtonsBlock();
+            buttons[0].ButtonLabel = Util.StringToBytes256("!!llTextBox!!");
+            dialog.Buttons = buttons;
+
+            dialog.OwnerData = new ScriptDialogPacket.OwnerDataBlock[1];
+            dialog.OwnerData[0] = new ScriptDialogPacket.OwnerDataBlock();
+            dialog.OwnerData[0].OwnerID = ownerID;
+
+            OutPacket(dialog, ThrottleOutPacketType.Task);
+        }
+
+        public void StopFlying(ISceneEntity p)
+        {
+            if (p is ScenePresence)
+            {
+                ScenePresence presence = p as ScenePresence;
+                // It turns out to get the agent to stop flying, you have to feed it stop flying velocities
+                // There's no explicit message to send the client to tell it to stop flying..   it relies on the
+                // velocity, collision plane and avatar height
+
+                // Add 1/6 the avatar's height to it's position so it doesn't shoot into the air
+                // when the avatar stands up
+
+                Vector3 pos = presence.AbsolutePosition;
+
+                if (presence.Appearance.AvatarHeight != 127.0f)
+                    pos += new Vector3(0f, 0f, (presence.Appearance.AvatarHeight/6f));
+                else
+                    pos += new Vector3(0f, 0f, (1.56f/6f));
+
+                presence.AbsolutePosition = pos;
+
+                // attach a suitable collision plane regardless of the actual situation to force the LLClient to land.
+                // Collision plane below the avatar's position a 6th of the avatar's height is suitable.
+                // Mind you, that this method doesn't get called if the avatar's velocity magnitude is greater then a
+                // certain amount..   because the LLClient wouldn't land in that situation anyway.
+
+                // why are we still testing for this really old height value default???
+                if (presence.Appearance.AvatarHeight != 127.0f)
+                    presence.CollisionPlane = new Vector4(0, 0, 0, pos.Z - presence.Appearance.AvatarHeight/6f);
+                else
+                    presence.CollisionPlane = new Vector4(0, 0, 0, pos.Z - (1.56f/6f));
+
+
+                ImprovedTerseObjectUpdatePacket.ObjectDataBlock block =
+                    CreateImprovedTerseBlock(p, false);
+
+                const float TIME_DILATION = 1.0f;
+                ushort timeDilation = Utils.FloatToUInt16(TIME_DILATION, 0.0f, 1.0f);
+
+
+                ImprovedTerseObjectUpdatePacket packet = new ImprovedTerseObjectUpdatePacket();
+                packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                packet.RegionData.TimeDilation = timeDilation;
+                packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[1];
+
+                packet.ObjectData[0] = block;
+
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
+            }
+
+            //ControllingClient.SendAvatarTerseUpdate(new SendAvatarTerseData(m_rootRegionHandle, (ushort)(m_scene.TimeDilation * ushort.MaxValue), LocalId,
+            //        AbsolutePosition, Velocity, Vector3.Zero, m_bodyRot, new Vector4(0,0,1,AbsolutePosition.Z - 0.5f), m_uuid, null, GetUpdatePriority(ControllingClient)));
+        }
+
+        public void SendPlacesReply(UUID queryID, UUID transactionID,
+                PlacesReplyData[] data)
+        {
+            PlacesReplyPacket reply = null;
+            PlacesReplyPacket.QueryDataBlock[] dataBlocks = 
+                    new PlacesReplyPacket.QueryDataBlock[0];
+
+            for (int i = 0 ; i < data.Length ; i++)
+            {
+                PlacesReplyPacket.QueryDataBlock block =
+                        new PlacesReplyPacket.QueryDataBlock();
+
+                block.OwnerID = data[i].OwnerID;
+                block.Name = Util.StringToBytes256(data[i].Name);
+                block.Desc = Util.StringToBytes1024(data[i].Desc);
+                block.ActualArea = data[i].ActualArea;
+                block.BillableArea = data[i].BillableArea;
+                block.Flags = data[i].Flags;
+                block.GlobalX = data[i].GlobalX;
+                block.GlobalY = data[i].GlobalY;
+                block.GlobalZ = data[i].GlobalZ;
+                block.SimName = Util.StringToBytes256(data[i].SimName);
+                block.SnapshotID = data[i].SnapshotID;
+                block.Dwell = data[i].Dwell;
+                block.Price = data[i].Price;
+
+                if (reply != null && reply.Length + block.Length > 1400)
+                {
+                    OutPacket(reply, ThrottleOutPacketType.Task);
+
+                    reply = null;
+                    dataBlocks = new PlacesReplyPacket.QueryDataBlock[0];
+                }
+
+                if (reply == null)
+                {
+                    reply = (PlacesReplyPacket)PacketPool.Instance.GetPacket(PacketType.PlacesReply);
+                    reply.AgentData = new PlacesReplyPacket.AgentDataBlock();
+                    reply.AgentData.AgentID = AgentId;
+                    reply.AgentData.QueryID = queryID;
+
+                    reply.TransactionData = new PlacesReplyPacket.TransactionDataBlock();
+                    reply.TransactionData.TransactionID = transactionID;
+
+                    reply.QueryData = dataBlocks;
+                }
+
+                Array.Resize(ref dataBlocks, dataBlocks.Length + 1);
+                dataBlocks[dataBlocks.Length - 1] = block;
+                reply.QueryData = dataBlocks;
+            }
+            if (reply != null)
+                OutPacket(reply, ThrottleOutPacketType.Task);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLImageManager.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs
index 938cf50..9e0db12 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLImageManager.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs
@@ -58,8 +58,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         private C5.IntervalHeap<J2KImage> m_priorityQueue = new C5.IntervalHeap<J2KImage>(10, new J2KImageComparer());
         private object m_syncRoot = new object();
 
-        private IHyperAssetService m_hyperAssets;
-
         public LLClientView Client { get { return m_client; } }
         public AssetBase MissingImage { get { return m_missingImage; } }
 
@@ -75,7 +73,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_log.Error("[ClientView] - Couldn't set missing image asset, falling back to missing image packet. This is known to crash the client");
 
             m_j2kDecodeModule = pJ2kDecodeModule;
-            m_hyperAssets = client.Scene.RequestModuleInterface<IHyperAssetService>();
         }
 
         /// <summary>
@@ -149,7 +146,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         imgrequest.J2KDecoder = m_j2kDecodeModule;
                         imgrequest.AssetService = m_assetCache;
                         imgrequest.AgentID = m_client.AgentId;
-                        imgrequest.HyperAssets = m_hyperAssets;
+                        imgrequest.InventoryAccessModule = m_client.Scene.RequestModuleInterface<IInventoryAccessModule>();
                         imgrequest.DiscardLevel = newRequest.DiscardLevel;
                         imgrequest.StartPacket = Math.Max(1, newRequest.PacketNumber);
                         imgrequest.Priority = newRequest.Priority;
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs
index 55d9c9c..ae72175 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs
@@ -122,6 +122,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public int PacketsReceived;
         /// <summary>Number of packets sent to this client</summary>
         public int PacketsSent;
+        /// <summary>Number of packets resent to this client</summary>
+        public int PacketsResent;        
         /// <summary>Total byte count of unacked packets sent to this client</summary>
         public int UnackedBytes;
 
@@ -133,7 +135,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         private int m_nextOnQueueEmpty = 1;
 
         /// <summary>Throttle bucket for this agent's connection</summary>
-        private readonly TokenBucket m_throttle;
+        private readonly AdaptiveTokenBucket m_throttleClient;
+        public AdaptiveTokenBucket FlowThrottle
+        {
+            get { return m_throttleClient; }
+        }
+
+        /// <summary>Throttle bucket for this agent's connection</summary>
+        private readonly TokenBucket m_throttleCategory;
         /// <summary>Throttle buckets for each packet category</summary>
         private readonly TokenBucket[] m_throttleCategories;
         /// <summary>Outgoing queues for throttled packets</summary>
@@ -144,8 +153,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>A reference to the LLUDPServer that is managing this client</summary>
         private readonly LLUDPServer m_udpServer;
 
-        private int m_defaultRTO = 3000;
+        /// <summary>Caches packed throttle information</summary>
+        private byte[] m_packedThrottles;
+
+        private int m_defaultRTO = 1000; // 1sec is the recommendation in the RFC
         private int m_maxRTO = 60000;
+        public bool m_deliverPackets = true;
 
         /// <summary>
         /// Default constructor
@@ -157,7 +170,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="circuitCode">Circuit code for this connection</param>
         /// <param name="agentID">AgentID for the connected agent</param>
         /// <param name="remoteEndPoint">Remote endpoint for this connection</param>
-        public LLUDPClient(LLUDPServer server, ThrottleRates rates, TokenBucket parentThrottle, uint circuitCode, UUID agentID, IPEndPoint remoteEndPoint, int defaultRTO, int maxRTO)
+        /// <param name="defaultRTO">
+        /// Default retransmission timeout for unacked packets.  The RTO will never drop
+        /// beyond this number.
+        /// </param>
+        /// <param name="maxRTO">
+        /// The maximum retransmission timeout for unacked packets.  The RTO will never exceed this number.
+        /// </param>
+        public LLUDPClient(
+            LLUDPServer server, ThrottleRates rates, TokenBucket parentThrottle, uint circuitCode, UUID agentID,
+            IPEndPoint remoteEndPoint, int defaultRTO, int maxRTO)
         {
             AgentID = agentID;
             RemoteEndPoint = remoteEndPoint;
@@ -169,7 +191,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_maxRTO = maxRTO;
 
             // Create a token bucket throttle for this client that has the scene token bucket as a parent
-            m_throttle = new TokenBucket(parentThrottle, rates.TotalLimit, rates.Total);
+            m_throttleClient = new AdaptiveTokenBucket(parentThrottle, rates.Total, rates.AdaptiveThrottlesEnabled);
+            // Create a token bucket throttle for the total categary with the client bucket as a throttle
+            m_throttleCategory = new TokenBucket(m_throttleClient, 0);
             // Create an array of token buckets for this clients different throttle categories
             m_throttleCategories = new TokenBucket[THROTTLE_CATEGORY_COUNT];
 
@@ -180,10 +204,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 // Initialize the packet outboxes, where packets sit while they are waiting for tokens
                 m_packetOutboxes[i] = new OpenSim.Framework.LocklessQueue<OutgoingPacket>();
                 // Initialize the token buckets that control the throttling for each category
-                m_throttleCategories[i] = new TokenBucket(m_throttle, rates.GetLimit(type), rates.GetRate(type));
+                m_throttleCategories[i] = new TokenBucket(m_throttleCategory, rates.GetRate(type));
             }
 
-            // Default the retransmission timeout to three seconds
+            // Default the retransmission timeout to one second
             RTO = m_defaultRTO;
 
             // Initialize this to a sane value to prevent early disconnects
@@ -201,6 +225,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_packetOutboxes[i].Clear();
                 m_nextPackets[i] = null;
             }
+
+            // pull the throttle out of the scene throttle
+            m_throttleClient.Parent.UnregisterRequest(m_throttleClient);
             OnPacketStats = null;
             OnQueueEmpty = null;
         }
@@ -218,15 +245,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             info.pendingAcks = new Dictionary<uint, uint>();
             info.needAck = new Dictionary<uint, byte[]>();
 
-            info.resendThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Resend].DripRate;
-            info.landThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Land].DripRate;
-            info.windThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Wind].DripRate;
-            info.cloudThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Cloud].DripRate;
-            info.taskThrottle = m_throttleCategories[(int)ThrottleOutPacketType.State].DripRate + m_throttleCategories[(int)ThrottleOutPacketType.Task].DripRate;
-            info.assetThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Asset].DripRate;
-            info.textureThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Texture].DripRate;
-            info.totalThrottle = info.resendThrottle + info.landThrottle + info.windThrottle + info.cloudThrottle +
-                info.taskThrottle + info.assetThrottle + info.textureThrottle;
+            info.resendThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Resend].DripRate;
+            info.landThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Land].DripRate;
+            info.windThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Wind].DripRate;
+            info.cloudThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Cloud].DripRate;
+            info.taskThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Task].DripRate;
+            info.assetThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Asset].DripRate;
+            info.textureThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Texture].DripRate;
+            info.totalThrottle = (int)m_throttleCategory.DripRate;
 
             return info;
         }
@@ -243,11 +269,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Return statistics information about client packet queues.
+        /// </summary>
+        /// <remarks>
+        /// FIXME: This should really be done in a more sensible manner rather than sending back a formatted string.
+        /// </remarks>
+        /// <returns></returns>
         public string GetStats()
         {
-            // TODO: ???
-            return string.Format("{0,7} {1,7} {2,7} {3,7} {4,7} {5,7} {6,7} {7,7} {8,7} {9,7}",
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            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}",
+                PacketsReceived,                                 
+                PacketsSent,
+                PacketsResent,
+                UnackedBytes,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Resend].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Land].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Wind].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Cloud].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Task].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Texture].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.Asset].Count,
+                m_packetOutboxes[(int)ThrottleOutPacketType.State].Count);                                
         }
 
         public void SendPacketStats()
@@ -294,8 +338,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             int texture = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
             int asset = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f);
             // State is a subcategory of task that we allocate a percentage to
-            int state = (int)((float)task * STATE_TASK_PERCENTAGE);
-            task -= state;
+            int state = 0;
 
             // Make sure none of the throttles are set below our packet MTU,
             // otherwise a throttle could become permanently clogged
@@ -306,86 +349,124 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             task = Math.Max(task, LLUDPServer.MTU);
             texture = Math.Max(texture, LLUDPServer.MTU);
             asset = Math.Max(asset, LLUDPServer.MTU);
-            state = Math.Max(state, LLUDPServer.MTU);
-
-            int total = resend + land + wind + cloud + task + texture + asset + state;
 
-            //m_log.DebugFormat("[LLUDPCLIENT]: {0} is setting throttles. Resend={1}, Land={2}, Wind={3}, Cloud={4}, Task={5}, Texture={6}, Asset={7}, State={8}, Total={9}",
-            //    AgentID, resend, land, wind, cloud, task, texture, asset, state, total);
+            //int total = resend + land + wind + cloud + task + texture + asset;
+            //m_log.DebugFormat("[LLUDPCLIENT]: {0} is setting throttles. Resend={1}, Land={2}, Wind={3}, Cloud={4}, Task={5}, Texture={6}, Asset={7}, Total={8}",
+            //                  AgentID, resend, land, wind, cloud, task, texture, asset, total);
 
             // Update the token buckets with new throttle values
             TokenBucket bucket;
 
-            bucket = m_throttle;
-            bucket.MaxBurst = total;
-
             bucket = m_throttleCategories[(int)ThrottleOutPacketType.Resend];
-            bucket.DripRate = resend;
-            bucket.MaxBurst = resend;
+            bucket.RequestedDripRate = resend;
 
             bucket = m_throttleCategories[(int)ThrottleOutPacketType.Land];
-            bucket.DripRate = land;
-            bucket.MaxBurst = land;
+            bucket.RequestedDripRate = land;
 
             bucket = m_throttleCategories[(int)ThrottleOutPacketType.Wind];
-            bucket.DripRate = wind;
-            bucket.MaxBurst = wind;
+            bucket.RequestedDripRate = wind;
 
             bucket = m_throttleCategories[(int)ThrottleOutPacketType.Cloud];
-            bucket.DripRate = cloud;
-            bucket.MaxBurst = cloud;
+            bucket.RequestedDripRate = cloud;
 
             bucket = m_throttleCategories[(int)ThrottleOutPacketType.Asset];
-            bucket.DripRate = asset;
-            bucket.MaxBurst = asset;
+            bucket.RequestedDripRate = asset;
 
             bucket = m_throttleCategories[(int)ThrottleOutPacketType.Task];
-            bucket.DripRate = task + state;
-            bucket.MaxBurst = task + state;
+            bucket.RequestedDripRate = task;
 
             bucket = m_throttleCategories[(int)ThrottleOutPacketType.State];
-            bucket.DripRate = state;
-            bucket.MaxBurst = state;
+            bucket.RequestedDripRate = state;
 
             bucket = m_throttleCategories[(int)ThrottleOutPacketType.Texture];
-            bucket.DripRate = texture;
-            bucket.MaxBurst = texture;
+            bucket.RequestedDripRate = texture;
+
+            // Reset the packed throttles cached data
+            m_packedThrottles = null;
         }
 
-        public byte[] GetThrottlesPacked()
+        public byte[] GetThrottlesPacked(float multiplier)
         {
-            byte[] data = new byte[7 * 4];
-            int i = 0;
-
-            Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Resend].DripRate), 0, data, i, 4); i += 4;
-            Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Land].DripRate), 0, data, i, 4); i += 4;
-            Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Wind].DripRate), 0, data, i, 4); i += 4;
-            Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Cloud].DripRate), 0, data, i, 4); i += 4;
-            Buffer.BlockCopy(Utils.FloatToBytes((float)(m_throttleCategories[(int)ThrottleOutPacketType.Task].DripRate) +
-                                                        m_throttleCategories[(int)ThrottleOutPacketType.State].DripRate), 0, data, i, 4); i += 4;
-            Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Texture].DripRate), 0, data, i, 4); i += 4;
-            Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Asset].DripRate), 0, data, i, 4); i += 4;
+            byte[] data = m_packedThrottles;
+
+            if (data == null)
+            {
+                float rate;
+
+                data = new byte[7 * 4];
+                int i = 0;
+
+                // multiply by 8 to convert bytes back to bits
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Resend].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Land].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Wind].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Cloud].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Task].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Texture].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Asset].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                m_packedThrottles = data;
+            }
 
             return data;
         }
 
-        public bool EnqueueOutgoing(OutgoingPacket packet)
+        /// <summary>
+        /// Queue an outgoing packet if appropriate.
+        /// </summary>
+        /// <param name="packet"></param>
+        /// <param name="forceQueue">Always queue the packet if at all possible.</param>
+        /// <returns>
+        /// true if the packet has been queued, 
+        /// false if the packet has not been queued and should be sent immediately.
+        /// </returns>
+        public bool EnqueueOutgoing(OutgoingPacket packet, bool forceQueue)
         {
             int category = (int)packet.Category;
 
             if (category >= 0 && category < m_packetOutboxes.Length)
             {
                 OpenSim.Framework.LocklessQueue<OutgoingPacket> queue = m_packetOutboxes[category];
+
+                if (m_deliverPackets == false)
+                {
+                    queue.Enqueue(packet);
+                    return true;
+                }
+
                 TokenBucket bucket = m_throttleCategories[category];
 
-                if (bucket.RemoveTokens(packet.Buffer.DataLength))
+                // 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)
+                {
+                    queue.Enqueue(packet);
+                    return true;
+                }
+                
+                    
+                if (!forceQueue && bucket.RemoveTokens(packet.Buffer.DataLength))
                 {
                     // Enough tokens were removed from the bucket, the packet will not be queued
                     return false;
                 }
                 else
                 {
-                    // Not enough tokens in the bucket, queue this packet
+                    // Force queue specified or not enough tokens in the bucket, queue this packet
                     queue.Enqueue(packet);
                     return true;
                 }
@@ -399,14 +480,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         /// <summary>
         /// Loops through all of the packet queues for this client and tries to send
-        /// any outgoing packets, obeying the throttling bucket limits
+        /// an outgoing packet from each, obeying the throttling bucket limits
         /// </summary>
-        /// <remarks>This function is only called from a synchronous loop in the
-        /// UDPServer so we don't need to bother making this thread safe</remarks>
+        /// 
+        /// <remarks>
+        /// Packet queues are inspected in ascending numerical order starting from 0.  Therefore, queues with a lower 
+        /// ThrottleOutPacketType number will see their packet get sent first (e.g. if both Land and Wind queues have
+        /// packets, then the packet at the front of the Land queue will be sent before the packet at the front of the
+        /// wind queue).
+        /// 
+        /// This function is only called from a synchronous loop in the
+        /// UDPServer so we don't need to bother making this thread safe
+        /// </remarks>
+        /// 
         /// <returns>True if any packets were sent, otherwise false</returns>
         public bool DequeueOutgoing()
         {
-            OutgoingPacket packet;
+            if (m_deliverPackets == false) return false;
+
+            OutgoingPacket packet = null;
             OpenSim.Framework.LocklessQueue<OutgoingPacket> queue;
             TokenBucket bucket;
             bool packetSent = false;
@@ -431,7 +523,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         m_udpServer.SendPacketFinal(nextPacket);
                         m_nextPackets[i] = null;
                         packetSent = true;
-                        this.PacketsSent++;
                     }
                 }
                 else
@@ -439,33 +530,49 @@ 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;
-                            this.PacketsSent++;
+                            success = queue.Dequeue(out packet);
                         }
-                        else
+                        catch
                         {
-                            // Save the dequeued packet for the next iteration
-                            m_nextPackets[i] = packet;
+                            m_packetOutboxes[i] = new OpenSim.Framework.LocklessQueue<OutgoingPacket>();
                         }
-
-                        // 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)
+                        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;
+                            }
+                            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)
+                                emptyCategories |= CategoryToFlag(i);
+                        }
+                        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 OpenSim.Framework.LocklessQueue<OutgoingPacket>();
                         emptyCategories |= CategoryToFlag(i);
                     }
                 }
@@ -508,12 +615,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             int rto = (int)(SRTT + Math.Max(m_udpServer.TickCountResolution, K * RTTVAR));
 
             // Clamp the retransmission timeout to manageable values
-            rto = Utils.Clamp(RTO, m_defaultRTO, m_maxRTO);
+            rto = Utils.Clamp(rto, m_defaultRTO, m_maxRTO);
 
             RTO = rto;
 
-            //m_log.Debug("[LLUDPCLIENT]: Setting agent " + this.Agent.FullName + "'s RTO to " + RTO + "ms with an RTTVAR of " +
-            //    RTTVAR + " based on new RTT of " + r + "ms");
+            //if (RTO != rto)
+       //          m_log.Debug("[LLUDPCLIENT]: Setting RTO to " + RTO + "ms from " + rto + "ms with an RTTVAR of " +
+                       //RTTVAR + " based on new RTT of " + r + "ms");
         }
 
         /// <summary>
@@ -535,8 +643,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// Does an early check to see if this queue empty callback is already
         /// running, then asynchronously firing the event
         /// </summary>
-        /// <param name="throttleIndex">Throttle category to fire the callback
-        /// for</param>
+        /// <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)
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
index 5ed4cd7..bf5b85a 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Net;
 using System.Net.Sockets;
@@ -99,15 +100,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         /// <summary>The measured resolution of Environment.TickCount</summary>
         public readonly float TickCountResolution;
-        /// <summary>Number of terse 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 PrimTerseUpdatesPerPacket;
-        /// <summary>Number of terse avatar updates to put on the queue each time the
-        /// OnQueueEmpty event is triggered for updates</summary>
-        public readonly int AvatarTerseUpdatesPerPacket;
-        /// <summary>Number of full prim updates to put on the queue each time the
-        /// OnQueueEmpty event is triggered for updates</summary>
-        public readonly int PrimFullUpdatesPerPacket;
+        public readonly int PrimUpdatesPerCallback;
         /// <summary>Number of texture packets to put on the queue each time the
         /// OnQueueEmpty event is triggered for textures</summary>
         public readonly int TextureSendLimit;
@@ -120,8 +115,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         //private UDPClientCollection m_clients = new UDPClientCollection();
         /// <summary>Bandwidth throttle for this UDP server</summary>
         protected TokenBucket m_throttle;
+        
         /// <summary>Bandwidth throttle rates for this UDP server</summary>
-        protected ThrottleRates m_throttleRates;
+        public ThrottleRates ThrottleRates { get; private set; }
+        
         /// <summary>Manages authentication for agent circuits</summary>
         private AgentCircuitManager m_circuitManager;
         /// <summary>Reference to the scene this UDP server is attached to</summary>
@@ -159,8 +156,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         private int m_defaultRTO = 0;
         private int m_maxRTO = 0;
 
+        private bool m_disableFacelights = false;
+
         public Socket Server { get { return null; } }
 
+        private int m_malformedCount = 0; // Guard against a spamming attack
+
         public LLUDPServer(IPAddress listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port, IConfigSource configSource, AgentCircuitManager circuitManager)
             : base(listenIP, (int)port)
         {
@@ -187,23 +188,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             IConfig config = configSource.Configs["ClientStack.LindenUDP"];
             if (config != null)
             {
-                m_asyncPacketHandling = config.GetBoolean("async_packet_handling", false);
+                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);
 
-                PrimTerseUpdatesPerPacket = config.GetInt("PrimTerseUpdatesPerPacket", 25);
-                AvatarTerseUpdatesPerPacket = config.GetInt("AvatarTerseUpdatesPerPacket", 10);
-                PrimFullUpdatesPerPacket = config.GetInt("PrimFullUpdatesPerPacket", 100);
+                PrimUpdatesPerCallback = config.GetInt("PrimUpdatesPerCallback", 100);
                 TextureSendLimit = config.GetInt("TextureSendLimit", 20);
 
                 m_defaultRTO = config.GetInt("DefaultRTO", 0);
                 m_maxRTO = config.GetInt("MaxRTO", 0);
+                m_disableFacelights = config.GetBoolean("DisableFacelights", false);
             }
             else
             {
-                PrimTerseUpdatesPerPacket = 25;
-                AvatarTerseUpdatesPerPacket = 10;
-                PrimFullUpdatesPerPacket = 100;
+                PrimUpdatesPerCallback = 100;
                 TextureSendLimit = 20;
             }
 
@@ -232,8 +230,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            }
            #endregion BinaryStats
 
-            m_throttle = new TokenBucket(null, sceneThrottleBps, sceneThrottleBps);
-            m_throttleRates = new ThrottleRates(configSource);
+            m_throttle = new TokenBucket(null, sceneThrottleBps);
+            ThrottleRates = new ThrottleRates(configSource);
         }
 
         public void Start()
@@ -301,7 +299,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         delegate(IClientAPI client)
                         {
                             if (client is LLClientView)
-                                SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category);
+                                SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category, null);
                         }
                     );
                 }
@@ -313,13 +311,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     delegate(IClientAPI client)
                     {
                         if (client is LLClientView)
-                            SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category);
+                            SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category, null);
                     }
                 );
             }
         }
 
-        public void SendPacket(LLUDPClient udpClient, Packet packet, ThrottleOutPacketType category, bool allowSplitting)
+        /// <summary>
+        /// Start the process of sending a packet to the client.
+        /// </summary>
+        /// <param name="udpClient"></param>
+        /// <param name="packet"></param>
+        /// <param name="category"></param>
+        /// <param name="allowSplitting"></param>
+        /// <param name="method">
+        /// The method to call if the packet is not acked by the client.  If null, then a standard
+        /// resend of the packet is done.
+        /// </param>
+        public virtual void SendPacket(
+            LLUDPClient udpClient, Packet packet, ThrottleOutPacketType category, bool allowSplitting, UnackedPacketMethod method)
         {
             // CoarseLocationUpdate packets cannot be split in an automated way
             if (packet.Type == PacketType.CoarseLocationUpdate && allowSplitting)
@@ -336,17 +346,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 for (int i = 0; i < packetCount; i++)
                 {
                     byte[] data = datas[i];
-                    SendPacketData(udpClient, data, packet.Type, category);
+                    SendPacketData(udpClient, data, packet.Type, category, method);
                 }
             }
             else
             {
                 byte[] data = packet.ToBytes();
-                SendPacketData(udpClient, data, packet.Type, category);
+                SendPacketData(udpClient, data, packet.Type, category, method);
             }
         }
 
-        public void SendPacketData(LLUDPClient udpClient, byte[] data, PacketType type, ThrottleOutPacketType category)
+        /// <summary>
+        /// Start the process of sending a packet to the client.
+        /// </summary>
+        /// <param name="udpClient"></param>
+        /// <param name="data"></param>
+        /// <param name="type"></param>
+        /// <param name="category"></param>
+        /// <param name="method">
+        /// The method to call if the packet is not acked by the client.  If null, then a standard
+        /// resend of the packet is done.
+        /// </param>
+        public void SendPacketData(
+            LLUDPClient udpClient, byte[] data, PacketType type, ThrottleOutPacketType category, UnackedPacketMethod method)
         {
             int dataLength = data.Length;
             bool doZerocode = (data[0] & Helpers.MSG_ZEROCODED) != 0;
@@ -401,9 +423,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             #region Queue or Send
 
-            OutgoingPacket outgoingPacket = new OutgoingPacket(udpClient, buffer, category);
+            OutgoingPacket outgoingPacket = new OutgoingPacket(udpClient, buffer, category, null);
+            // If we were not provided a method for handling unacked, use the UDPServer default method
+            outgoingPacket.UnackedMethod = ((method == null) ? delegate(OutgoingPacket oPacket) { ResendUnacked(oPacket); } : method);
 
-            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
+            // If a Linden Lab 1.23.5 client receives an update packet after a kill packet for an object, it will 
+            // continue to display the deleted object until relog.  Therefore, we need to always queue a kill object
+            // packet so that it isn't sent before a queued update packet.
+            bool requestQueue = type == PacketType.KillObject;
+            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket, requestQueue))
                 SendPacketFinal(outgoingPacket);
 
             #endregion Queue or Send
@@ -431,7 +459,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 packet.Header.Reliable = false;
                 packet.Packets = blocks.ToArray();
 
-                SendPacket(udpClient, packet, ThrottleOutPacketType.Unknown, true);
+                SendPacket(udpClient, packet, ThrottleOutPacketType.Unknown, true, null);
             }
         }
 
@@ -444,17 +472,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // We *could* get OldestUnacked, but it would hurt performance and not provide any benefit
             pc.PingID.OldestUnacked = 0;
 
-            SendPacket(udpClient, pc, ThrottleOutPacketType.Unknown, false);
+            SendPacket(udpClient, pc, ThrottleOutPacketType.Unknown, false, null);
         }
 
         public void CompletePing(LLUDPClient udpClient, byte pingID)
         {
             CompletePingCheckPacket completePing = new CompletePingCheckPacket();
             completePing.PingID.PingID = pingID;
-            SendPacket(udpClient, completePing, ThrottleOutPacketType.Unknown, false);
+            SendPacket(udpClient, completePing, ThrottleOutPacketType.Unknown, false, null);
         }
 
-        public void ResendUnacked(LLUDPClient udpClient)
+        public void HandleUnacked(LLUDPClient udpClient)
         {
             if (!udpClient.IsConnected)
                 return;
@@ -474,32 +502,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             if (expiredPackets != null)
             {
-                //m_log.Debug("[LLUDPSERVER]: Resending " + expiredPackets.Count + " packets to " + udpClient.AgentID + ", RTO=" + udpClient.RTO);
-
+                //m_log.Debug("[LLUDPSERVER]: Handling " + expiredPackets.Count + " packets to " + udpClient.AgentID + ", RTO=" + udpClient.RTO);
                 // Exponential backoff of the retransmission timeout
                 udpClient.BackoffRTO();
+                for (int i = 0; i < expiredPackets.Count; ++i)
+                    expiredPackets[i].UnackedMethod(expiredPackets[i]);
+            }
+        }
 
-                // Resend packets
-                for (int i = 0; i < expiredPackets.Count; i++)
-                {
-                    OutgoingPacket outgoingPacket = expiredPackets[i];
-
-                    //m_log.DebugFormat("[LLUDPSERVER]: Resending packet #{0} (attempt {1}), {2}ms have passed",
-                    //    outgoingPacket.SequenceNumber, outgoingPacket.ResendCount, Environment.TickCount - outgoingPacket.TickCount);
+        public void ResendUnacked(OutgoingPacket outgoingPacket)
+        {
+            //m_log.DebugFormat("[LLUDPSERVER]: Resending packet #{0} (attempt {1}), {2}ms have passed",
+            //    outgoingPacket.SequenceNumber, outgoingPacket.ResendCount, Environment.TickCount - outgoingPacket.TickCount);
 
-                    // Set the resent flag
-                    outgoingPacket.Buffer.Data[0] = (byte)(outgoingPacket.Buffer.Data[0] | Helpers.MSG_RESENT);
-                    outgoingPacket.Category = ThrottleOutPacketType.Resend;
+            // Set the resent flag
+            outgoingPacket.Buffer.Data[0] = (byte)(outgoingPacket.Buffer.Data[0] | Helpers.MSG_RESENT);
+            outgoingPacket.Category = ThrottleOutPacketType.Resend;
 
-                    // Bump up the resend count on this packet
-                    Interlocked.Increment(ref outgoingPacket.ResendCount);
-                    //Interlocked.Increment(ref Stats.ResentPackets);
+            // Bump up the resend count on this packet
+            Interlocked.Increment(ref outgoingPacket.ResendCount);
 
-                    // Requeue or resend the packet
-                    if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
-                        SendPacketFinal(outgoingPacket);
-                }
-            }
+            // Requeue or resend the packet
+            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket, false))
+                SendPacketFinal(outgoingPacket);
         }
 
         public void Flush(LLUDPClient udpClient)
@@ -507,6 +532,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // FIXME: Implement?
         }
 
+        /// <summary>
+        /// Actually send a packet to a client.
+        /// </summary>
+        /// <param name="outgoingPacket"></param>
         internal void SendPacketFinal(OutgoingPacket outgoingPacket)
         {
             UDPPacketBuffer buffer = outgoingPacket.Buffer;
@@ -565,13 +594,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     udpClient.NeedAcks.Add(outgoingPacket);
                 }
             }
+            else
+            {
+                Interlocked.Increment(ref udpClient.PacketsResent);
+            }
 
             #endregion Sequence Number Assignment
 
             // Stats tracking
             Interlocked.Increment(ref udpClient.PacketsSent);
-            if (isReliable)
-                Interlocked.Add(ref udpClient.UnackedBytes, outgoingPacket.Buffer.DataLength);
 
             // Put the UDP payload on the wire
             AsyncBeginSend(buffer);
@@ -580,11 +611,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             outgoingPacket.TickCount = Environment.TickCount & Int32.MaxValue;
         }
 
-        protected override void PacketReceived(UDPPacketBuffer buffer)
+        public override void PacketReceived(UDPPacketBuffer buffer)
         {
             // Debugging/Profiling
             //try { Thread.CurrentThread.Name = "PacketReceived (" + m_scene.RegionInfo.RegionName + ")"; }
             //catch (Exception) { }
+//            m_log.DebugFormat(
+//                "[LLUDPSERVER]: Packet received from {0} in {1}", buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
 
             LLUDPClient udpClient = null;
             Packet packet = null;
@@ -593,6 +626,33 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             #region Decoding
 
+            if (buffer.DataLength < 7)
+            {
+//                m_log.WarnFormat(
+//                    "[LLUDPSERVER]: Dropping undersized packet with {0} bytes received from {1} in {2}",
+//                    buffer.DataLength, buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
+
+                return; // Drop undersizd packet
+            }
+
+            int headerLen = 7;
+            if (buffer.Data[6] == 0xFF)
+            {
+                if (buffer.Data[7] == 0xFF)
+                    headerLen = 10;
+                else
+                    headerLen = 8;
+            }
+
+            if (buffer.DataLength < headerLen)
+            {
+//                m_log.WarnFormat(
+//                    "[LLUDPSERVER]: Dropping packet with malformed header received from {0} in {1}",
+//                    buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
+
+                return; // Malformed header
+            }
+
             try
             {
                 packet = Packet.BuildPacket(buffer.Data, ref packetEnd,
@@ -601,15 +661,30 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             catch (MalformedDataException)
             {
-                m_log.ErrorFormat("[LLUDPSERVER]: Malformed data, cannot parse packet from {0}:\n{1}",
-                    buffer.RemoteEndPoint, Utils.BytesToHexString(buffer.Data, buffer.DataLength, null));
+            }
+            catch (IndexOutOfRangeException)
+            {
+//                m_log.WarnFormat(
+//                    "[LLUDPSERVER]: Dropping short packet received from {0} in {1}",
+//                    buffer.RemoteEndPoint, m_scene.RegionInfo.RegionName);
+
+                return; // Drop short packet
+            }
+            catch(Exception e)
+            {
+                if (m_malformedCount < 100)
+                    m_log.DebugFormat("[LLUDPSERVER]: Dropped malformed packet: " + e.ToString());
+                m_malformedCount++;
+                if ((m_malformedCount % 100000) == 0)
+                    m_log.DebugFormat("[LLUDPSERVER]: Received {0} malformed packets so far, probable network attack.", m_malformedCount);
             }
 
             // Fail-safe check
             if (packet == null)
             {
-                m_log.Warn("[LLUDPSERVER]: Couldn't build a message from incoming data " + buffer.DataLength +
-                    " bytes long from " + buffer.RemoteEndPoint);
+                m_log.ErrorFormat("[LLUDPSERVER]: Malformed data, cannot parse {0} byte packet from {1}:",
+                    buffer.DataLength, buffer.RemoteEndPoint);
+                m_log.Error(Utils.BytesToHexString(buffer.Data, buffer.DataLength, null));
                 return;
             }
 
@@ -620,13 +695,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // UseCircuitCode handling
             if (packet.Type == PacketType.UseCircuitCode)
             {
-                m_log.Debug("[LLUDPSERVER]: Handling UseCircuitCode packet from " + buffer.RemoteEndPoint);
                 object[] array = new object[] { buffer, packet };
 
-                if (m_asyncPacketHandling)
-                    Util.FireAndForget(HandleUseCircuitCode, array);
-                else
-                    HandleUseCircuitCode(array);
+                Util.FireAndForget(HandleUseCircuitCode, array);
 
                 return;
             }
@@ -658,7 +729,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (packet.Header.AppendedAcks && packet.Header.AckList != null)
             {
                 for (int i = 0; i < packet.Header.AckList.Length; i++)
-                    udpClient.NeedAcks.Remove(packet.Header.AckList[i], now, packet.Header.Resent);
+                    udpClient.NeedAcks.Acknowledge(packet.Header.AckList[i], now, packet.Header.Resent);
             }
 
             // Handle PacketAck packets
@@ -667,7 +738,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 PacketAckPacket ackPacket = (PacketAckPacket)packet;
 
                 for (int i = 0; i < ackPacket.Packets.Length; i++)
-                    udpClient.NeedAcks.Remove(ackPacket.Packets[i].ID, now, packet.Header.Resent);
+                    udpClient.NeedAcks.Acknowledge(ackPacket.Packets[i].ID, now, packet.Header.Resent);
 
                 // We don't need to do anything else with PacketAck packets
                 return;
@@ -703,9 +774,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (packet.Header.Reliable && !udpClient.PacketArchive.TryEnqueue(packet.Header.Sequence))
             {
                 if (packet.Header.Resent)
-                    m_log.Debug("[LLUDPSERVER]: Received a resend of already processed packet #" + packet.Header.Sequence + ", type: " + packet.Type);
-                else
-                    m_log.Warn("[LLUDPSERVER]: Received a duplicate (not marked as resend) of packet #" + packet.Header.Sequence + ", type: " + packet.Type);
+                    m_log.DebugFormat(
+                        "[LLUDPSERVER]: Received a resend of already processed packet #{0}, type {1} from {2}", 
+                        packet.Header.Sequence, packet.Type, client.Name);
+                 else
+                    m_log.WarnFormat(
+                        "[LLUDPSERVER]: Received a duplicate (not marked as resend) of packet #{0}, type {1} from {2}",
+                        packet.Header.Sequence, packet.Type, client.Name);
 
                 // Avoid firing a callback twice for the same packet
                 return;
@@ -827,19 +902,58 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private void HandleUseCircuitCode(object o)
         {
+//            DateTime startTime = DateTime.Now;
             object[] array = (object[])o;
             UDPPacketBuffer buffer = (UDPPacketBuffer)array[0];
-            UseCircuitCodePacket packet = (UseCircuitCodePacket)array[1];
+            UseCircuitCodePacket uccp = (UseCircuitCodePacket)array[1];
+            
+            m_log.DebugFormat("[LLUDPSERVER]: Handling UseCircuitCode request from {0}", buffer.RemoteEndPoint);
 
             IPEndPoint remoteEndPoint = (IPEndPoint)buffer.RemoteEndPoint;
 
-            // Begin the process of adding the client to the simulator
-            AddNewClient((UseCircuitCodePacket)packet, remoteEndPoint);
+            AuthenticateResponse sessionInfo;
+            if (IsClientAuthorized(uccp, out sessionInfo))
+            {
+                // Begin the process of adding the client to the simulator
+                IClientAPI client
+                    = AddClient(
+                        uccp.CircuitCode.Code,
+                        uccp.CircuitCode.ID,
+                        uccp.CircuitCode.SessionID,
+                        remoteEndPoint,
+                        sessionInfo);
+        
+                // 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(remoteEndPoint, 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)
+                    client.SceneAgent.SendInitialDataToMe();
+            }
+            else
+            {
+                // Don't create clients for unauthorized requesters.
+                m_log.WarnFormat(
+                    "[LLUDPSERVER]: Connection request for client {0} connecting with unnotified circuit code {1} from {2}",
+                    uccp.CircuitCode.ID, uccp.CircuitCode.Code, remoteEndPoint);
+            }
 
-            // Acknowledge the UseCircuitCode packet
-            SendAckImmediate(remoteEndPoint, packet.Header.Sequence);
+            //            m_log.DebugFormat(
+//                "[LLUDPSERVER]: Handling UseCircuitCode request from {0} took {1}ms", 
+//                buffer.RemoteEndPoint, (DateTime.Now - startTime).Milliseconds);
         }
 
+        /// <summary>
+        /// Send an ack immediately to the given endpoint.
+        /// </summary>
+        /// <remarks>
+        /// FIXME: Might be possible to use SendPacketData() like everything else, but this will require refactoring so
+        /// that we can obtain the UDPClient easily at this point.
+        /// </remarks>
+        /// <param name="remoteEndpoint"></param>
+        /// <param name="sequenceNumber"></param>
         private void SendAckImmediate(IPEndPoint remoteEndpoint, uint sequenceNumber)
         {
             PacketAckPacket ack = new PacketAckPacket();
@@ -848,6 +962,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             ack.Packets[0] = new PacketAckPacket.PacketsBlock();
             ack.Packets[0].ID = sequenceNumber;
 
+            SendAckImmediate(remoteEndpoint, ack);
+        }
+
+        public virtual void SendAckImmediate(IPEndPoint remoteEndpoint, PacketAckPacket ack)
+        {
             byte[] packetData = ack.ToBytes();
             int length = packetData.Length;
 
@@ -869,54 +988,39 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return sessionInfo.Authorised;
         }
 
-        private void AddNewClient(UseCircuitCodePacket useCircuitCode, IPEndPoint remoteEndPoint)
+        /// <summary>
+        /// Add a client.
+        /// </summary>
+        /// <param name="circuitCode"></param>
+        /// <param name="agentID"></param>
+        /// <param name="sessionID"></param>
+        /// <param name="remoteEndPoint"></param>
+        /// <param name="sessionInfo"></param>
+        /// <returns>The client if it was added.  Null if the client already existed.</returns>
+        protected virtual IClientAPI AddClient(
+            uint circuitCode, UUID agentID, UUID sessionID, IPEndPoint remoteEndPoint, AuthenticateResponse sessionInfo)
         {
-            UUID agentID = useCircuitCode.CircuitCode.ID;
-            UUID sessionID = useCircuitCode.CircuitCode.SessionID;
-            uint circuitCode = useCircuitCode.CircuitCode.Code;
+            IClientAPI client = null;
 
-            if (m_scene.RegionStatus != RegionStatus.SlaveScene)
+            // In priciple there shouldn't be more than one thread here, ever.
+            // But in case that happens, we need to synchronize this piece of code
+            // because it's too important
+            lock (this) 
             {
-                AuthenticateResponse sessionInfo;
-                if (IsClientAuthorized(useCircuitCode, out sessionInfo))
+                if (!m_scene.TryGetClient(agentID, out client))
                 {
-                    AddClient(circuitCode, agentID, sessionID, remoteEndPoint, sessionInfo);
-                }
-                else
-                {
-                    // Don't create circuits for unauthorized clients
-                    m_log.WarnFormat(
-                        "[LLUDPSERVER]: Connection request for client {0} connecting with unnotified circuit code {1} from {2}",
-                        useCircuitCode.CircuitCode.ID, useCircuitCode.CircuitCode.Code, remoteEndPoint);
-                }
-            }
-            else
-            {
-                // Slave regions don't accept new clients
-                m_log.Debug("[LLUDPSERVER]: Slave region " + m_scene.RegionInfo.RegionName + " ignoring UseCircuitCode packet");
-            }
-        }
+                    LLUDPClient udpClient = new LLUDPClient(this, ThrottleRates, m_throttle, circuitCode, agentID, remoteEndPoint, m_defaultRTO, m_maxRTO);
 
-        protected virtual void AddClient(uint circuitCode, UUID agentID, UUID sessionID, IPEndPoint remoteEndPoint, AuthenticateResponse sessionInfo)
-        {
-            // Create the LLUDPClient
-            LLUDPClient udpClient = new LLUDPClient(this, m_throttleRates, m_throttle, circuitCode, agentID, remoteEndPoint, m_defaultRTO, m_maxRTO);
-            IClientAPI existingClient;
+                    client = new LLClientView(remoteEndPoint, m_scene, this, udpClient, sessionInfo, agentID, sessionID, circuitCode);
+                    client.OnLogout += LogoutHandler;
 
-            if (!m_scene.TryGetClient(agentID, out existingClient))
-            {
-                // Create the LLClientView
-                LLClientView client = new LLClientView(remoteEndPoint, m_scene, this, udpClient, sessionInfo, agentID, sessionID, circuitCode);
-                client.OnLogout += LogoutHandler;
+                    ((LLClientView)client).DisableFacelights = m_disableFacelights;
 
-                // Start the IClientAPI
-                client.Start();
-            }
-            else
-            {
-                m_log.WarnFormat("[LLUDPSERVER]: Ignoring a repeated UseCircuitCode from {0} at {1} for circuit {2}",
-                    udpClient.AgentID, remoteEndPoint, circuitCode);
+                    client.Start();
+                }
             }
+
+            return client;
         }
 
         private void RemoveClient(LLUDPClient udpClient)
@@ -924,7 +1028,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // Remove this client from the scene
             IClientAPI client;
             if (m_scene.TryGetClient(udpClient.AgentID, out client))
-                client.Close();
+            {
+                client.IsLoggingOut = true;
+                client.Close(false);
+            }
         }
 
         private void IncomingPacketHandler()
@@ -935,6 +1042,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             while (base.IsRunning)
             {
+                m_scene.ThreadAlive(1);
                 try
                 {
                     IncomingPacket incomingPacket = null;
@@ -977,6 +1085,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             while (base.IsRunning)
             {
+                m_scene.ThreadAlive(2);
                 try
                 {
                     m_packetSent = false;
@@ -1021,9 +1130,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     #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
-                    m_scene.ForEachClient(clientPacketHandler, false);
+                    m_scene.ForEachClient(clientPacketHandler);
 
                     // If nothing was sent, sleep for the minimum amount of time before a
                     // token bucket could get more tokens
@@ -1052,18 +1167,110 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     if (udpClient.IsConnected)
                     {
                         if (m_resendUnacked)
-                            ResendUnacked(udpClient);
+                            HandleUnacked(udpClient);
+
+                        if (m_sendAcks)
+                            SendAcks(udpClient);
+
+                        if (m_sendPing)
+                            SendPing(udpClient);
+
+                        // Dequeue any outgoing packets that are within the throttle limits
+                        if (udpClient.DequeueOutgoing())
+                            m_packetSent = true;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                m_log.Error("[LLUDPSERVER]: OutgoingPacketHandler iteration for " + client.Name +
+                    " threw an exception: " + ex.Message, ex);
+            }
+        }
+
+        #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;
+
+        private void MonitoredClientOutgoingPacketHandler(IClientAPI client)
+        {
+            nticks++;
+            watch1.Start();
+            try
+            {
+                if (client is LLClientView)
+                {
+                    LLUDPClient udpClient = ((LLClientView)client).UDPClient;
+
+                    if (udpClient.IsConnected)
+                    {
+                        if (m_resendUnacked)
+                        {
+                            nticksUnack++;
+                            watch2.Start();
+
+                            HandleUnacked(udpClient);
+
+                            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);
 
+                            watch2.Stop();
+                            avgSendPingTicks = (nticksPing - 1) / (float)nticksPing * avgSendPingTicks + (watch2.ElapsedTicks / (float)nticksPing);
+                            watch2.Reset();
+                        }
+
+                        watch2.Start();
                         // Dequeue any outgoing packets that are within the throttle limits
                         if (udpClient.DequeueOutgoing())
+                        {
                             m_packetSent = true;
+                            npacksSent++;
+                        }
+                        else
+                            npackNotSent++;
+
+                        watch2.Stop();
+                        avgDequeueTicks = (nticks - 1) / (float)nticks * avgDequeueTicks + (watch2.ElapsedTicks / (float)nticks);
+                        watch2.Reset();
+
                     }
+                    else
+                        m_log.WarnFormat("[LLUDPSERVER]: Client is not connected");
                 }
             }
             catch (Exception ex)
@@ -1071,8 +1278,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_log.Error("[LLUDPSERVER]: OutgoingPacketHandler iteration for " + client.Name +
                     " threw an exception: " + ex.Message, ex);
             }
+            watch1.Stop();
+            avgProcessingTicks = (nticks - 1) / (float)nticks * avgProcessingTicks + (watch1.ElapsedTicks / (float)nticks);
+            watch1.Reset();
+
+            // reuse this -- it's every ~100ms
+            if (m_scene.EmergencyMonitoring && nticks % 100 == 0)
+            {
+                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;
+            }
+
         }
 
+        #endregion 
+
         private void ProcessInPacket(object state)
         {
             IncomingPacket incomingPacket = (IncomingPacket)state;
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
index d2779ba..cfe7c9d 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
@@ -44,7 +44,7 @@ namespace OpenMetaverse
         /// This method is called when an incoming packet is received
         /// </summary>
         /// <param name="buffer">Incoming packet buffer</param>
-        protected abstract void PacketReceived(UDPPacketBuffer buffer);
+        public abstract void PacketReceived(UDPPacketBuffer buffer);
 
         /// <summary>UDP port to bind to in server mode</summary>
         protected int m_udpPort;
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs b/OpenSim/Region/ClientStack/Linden/UDP/OutgoingPacket.cs
index 1a1a1cb..76c6c14 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/OutgoingPacket.cs
@@ -31,6 +31,8 @@ using OpenMetaverse;
 
 namespace OpenSim.Region.ClientStack.LindenUDP
 {
+
+    public delegate void UnackedPacketMethod(OutgoingPacket oPacket);
     /// <summary>
     /// Holds a reference to the <seealso cref="LLUDPClient"/> this packet is
     /// destined for, along with the serialized packet data, sequence number
@@ -52,6 +54,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public int TickCount;
         /// <summary>Category this packet belongs to</summary>
         public ThrottleOutPacketType Category;
+        /// <summary>The delegate to be called if this packet is determined to be unacknowledged</summary>
+        public UnackedPacketMethod UnackedMethod;
 
         /// <summary>
         /// Default constructor
@@ -60,11 +64,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="buffer">Serialized packet data. If the flags or sequence number
         /// need to be updated, they will be injected directly into this binary buffer</param>
         /// <param name="category">Throttling category for this packet</param>
-        public OutgoingPacket(LLUDPClient client, UDPPacketBuffer buffer, ThrottleOutPacketType category)
+        public OutgoingPacket(LLUDPClient client, UDPPacketBuffer buffer, ThrottleOutPacketType category, UnackedPacketMethod method)
         {
             Client = client;
             Buffer = buffer;
             Category = category;
+            UnackedMethod = method;
         }
     }
 }
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
new file mode 100644
index 0000000..a575e36
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Net;
+using log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+using OpenSim.Tests.Common.Mock;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    /// <summary>
+    /// This will contain basic tests for the LindenUDP client stack
+    /// </summary>
+    [TestFixture]
+    public class BasicCircuitTests
+    {
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
+        }
+
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten so none of them require async stuff (which regression
+            // tests really shouldn't).
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
+
+//        /// <summary>
+//        /// Add a client for testing
+//        /// </summary>
+//        /// <param name="scene"></param>
+//        /// <param name="testLLUDPServer"></param>
+//        /// <param name="testPacketServer"></param>
+//        /// <param name="acm">Agent circuit manager used in setting up the stack</param>
+//        protected void SetupStack(
+//            IScene scene, out TestLLUDPServer testLLUDPServer, out TestLLPacketServer testPacketServer, 
+//            out AgentCircuitManager acm)
+//        {
+//            IConfigSource configSource = new IniConfigSource();
+//            ClientStackUserSettings userSettings = new ClientStackUserSettings();
+//            testLLUDPServer = new TestLLUDPServer();
+//            acm = new AgentCircuitManager();
+//                                    
+//            uint port = 666;
+//            testLLUDPServer.Initialise(null, ref port, 0, false, configSource, acm);
+//            testPacketServer = new TestLLPacketServer(testLLUDPServer, userSettings);
+//            testLLUDPServer.LocalScene = scene;
+//        }
+        
+//        /// <summary>
+//        /// Set up a client for tests which aren't concerned with this process itself and where only one client is being
+//        /// tested
+//        /// </summary>
+//        /// <param name="circuitCode"></param>
+//        /// <param name="epSender"></param>
+//        /// <param name="testLLUDPServer"></param>
+//        /// <param name="acm"></param>
+//        protected void AddClient(
+//            uint circuitCode, EndPoint epSender, TestLLUDPServer testLLUDPServer, AgentCircuitManager acm)
+//        {
+//            UUID myAgentUuid   = UUID.Parse("00000000-0000-0000-0000-000000000001");
+//            UUID mySessionUuid = UUID.Parse("00000000-0000-0000-0000-000000000002");
+//            
+//            AddClient(circuitCode, epSender, myAgentUuid, mySessionUuid, testLLUDPServer, acm);
+//        }
+        
+//        /// <summary>
+//        /// Set up a client for tests which aren't concerned with this process itself
+//        /// </summary>
+//        /// <param name="circuitCode"></param>
+//        /// <param name="epSender"></param>
+//        /// <param name="agentId"></param>
+//        /// <param name="sessionId"></param>
+//        /// <param name="testLLUDPServer"></param>
+//        /// <param name="acm"></param>
+//        protected void AddClient(
+//            uint circuitCode, EndPoint epSender, UUID agentId, UUID sessionId, 
+//            TestLLUDPServer testLLUDPServer, AgentCircuitManager acm)
+//        {
+//            AgentCircuitData acd = new AgentCircuitData();
+//            acd.AgentID = agentId;
+//            acd.SessionID = sessionId; 
+//            
+//            UseCircuitCodePacket uccp = new UseCircuitCodePacket();
+//            
+//            UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock 
+//                = new UseCircuitCodePacket.CircuitCodeBlock();
+//            uccpCcBlock.Code = circuitCode;
+//            uccpCcBlock.ID = agentId;
+//            uccpCcBlock.SessionID = sessionId;
+//            uccp.CircuitCode = uccpCcBlock;
+//
+//            acm.AddNewCircuit(circuitCode, acd);
+//            
+//            testLLUDPServer.LoadReceive(uccp, epSender);
+//            testLLUDPServer.ReceiveData(null);
+//        }
+        
+        /// <summary>
+        /// Build an object name packet for test purposes
+        /// </summary>
+        /// <param name="objectLocalId"></param>
+        /// <param name="objectName"></param>
+        protected ObjectNamePacket BuildTestObjectNamePacket(uint objectLocalId, string objectName)
+        {
+            ObjectNamePacket onp = new ObjectNamePacket();
+            ObjectNamePacket.ObjectDataBlock odb = new ObjectNamePacket.ObjectDataBlock();
+            odb.LocalID = objectLocalId;
+            odb.Name = Utils.StringToBytes(objectName);
+            onp.ObjectData = new ObjectNamePacket.ObjectDataBlock[] { odb };
+            onp.Header.Zerocoded = false;
+            
+            return onp;
+        }
+        
+        /// <summary>
+        /// Test adding a client to the stack
+        /// </summary>
+        [Test]
+        public void TestAddClient()
+        {
+            TestHelpers.InMethod();
+//            XmlConfigurator.Configure();
+
+            TestScene scene = SceneHelpers.SetupScene();
+            uint myCircuitCode = 123456;
+            UUID myAgentUuid   = TestHelpers.ParseTail(0x1);
+            UUID mySessionUuid = TestHelpers.ParseTail(0x2);
+            IPEndPoint testEp = new IPEndPoint(IPAddress.Loopback, 999);
+
+            uint port = 0;
+            AgentCircuitManager acm = scene.AuthenticateHandler;
+
+            TestLLUDPServer llUdpServer
+                = new TestLLUDPServer(IPAddress.Any, ref port, 0, false, new IniConfigSource(), acm);
+            llUdpServer.AddScene(scene);
+
+            UseCircuitCodePacket uccp = new UseCircuitCodePacket();
+
+            UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock
+                = new UseCircuitCodePacket.CircuitCodeBlock();
+            uccpCcBlock.Code = myCircuitCode;
+            uccpCcBlock.ID = myAgentUuid;
+            uccpCcBlock.SessionID = mySessionUuid;
+            uccp.CircuitCode = uccpCcBlock;
+
+            byte[] uccpBytes = uccp.ToBytes();
+            UDPPacketBuffer upb = new UDPPacketBuffer(testEp, uccpBytes.Length);
+            upb.DataLength = uccpBytes.Length;  // God knows why this isn't set by the constructor.
+            Buffer.BlockCopy(uccpBytes, 0, upb.Data, 0, uccpBytes.Length);
+
+            llUdpServer.PacketReceived(upb);
+
+            // Presence shouldn't exist since the circuit manager doesn't know about this circuit for authentication yet
+            Assert.That(scene.GetScenePresence(myAgentUuid), Is.Null);
+
+            AgentCircuitData acd = new AgentCircuitData();
+            acd.AgentID = myAgentUuid;
+            acd.SessionID = mySessionUuid;
+
+            acm.AddNewCircuit(myCircuitCode, acd);
+
+            llUdpServer.PacketReceived(upb);
+
+            // Should succeed now
+            ScenePresence sp = scene.GetScenePresence(myAgentUuid);
+            Assert.That(sp.UUID, Is.EqualTo(myAgentUuid));
+
+            Assert.That(llUdpServer.PacketsSent.Count, Is.EqualTo(1));
+
+            Packet packet = llUdpServer.PacketsSent[0];
+            Assert.That(packet, Is.InstanceOf(typeof(PacketAckPacket)));
+
+            PacketAckPacket ackPacket = packet as PacketAckPacket;
+            Assert.That(ackPacket.Packets.Length, Is.EqualTo(1));
+            Assert.That(ackPacket.Packets[0].ID, Is.EqualTo(0));
+        }
+
+//        /// <summary>
+//        /// Test removing a client from the stack
+//        /// </summary>
+//        [Test]
+//        public void TestRemoveClient()
+//        {
+//            TestHelper.InMethod();
+//
+//            uint myCircuitCode = 123457;
+//            
+//            TestLLUDPServer testLLUDPServer;
+//            TestLLPacketServer testLLPacketServer;
+//            AgentCircuitManager acm;
+//            SetupStack(new MockScene(), out testLLUDPServer, out testLLPacketServer, out acm);
+//            AddClient(myCircuitCode, new IPEndPoint(IPAddress.Loopback, 1000), testLLUDPServer, acm);
+//            
+//            testLLUDPServer.RemoveClientCircuit(myCircuitCode);
+//            Assert.IsFalse(testLLUDPServer.HasCircuit(myCircuitCode));
+//            
+//            // Check that removing a non-existant circuit doesn't have any bad effects
+//            testLLUDPServer.RemoveClientCircuit(101);
+//            Assert.IsFalse(testLLUDPServer.HasCircuit(101));
+//        }
+//        
+//        /// <summary>
+//        /// Make sure that the client stack reacts okay to malformed packets
+//        /// </summary>
+//        [Test]
+//        public void TestMalformedPacketSend()
+//        {
+//            TestHelper.InMethod();
+//
+//            uint myCircuitCode = 123458;
+//            EndPoint testEp = new IPEndPoint(IPAddress.Loopback, 1001);
+//            MockScene scene = new MockScene(); 
+//            
+//            TestLLUDPServer testLLUDPServer;
+//            TestLLPacketServer testLLPacketServer;
+//            AgentCircuitManager acm;
+//            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
+//            AddClient(myCircuitCode, testEp, testLLUDPServer, acm);
+//
+//            byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };
+//
+//            // Send two garbled 'packets' in succession
+//            testLLUDPServer.LoadReceive(data, testEp);
+//            testLLUDPServer.LoadReceive(data, testEp);
+//            testLLUDPServer.ReceiveData(null); 
+//            
+//            // Check that we are still here
+//            Assert.IsTrue(testLLUDPServer.HasCircuit(myCircuitCode));
+//            Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(0));
+//            
+//            // Check that sending a valid packet to same circuit still succeeds
+//            Assert.That(scene.ObjectNameCallsReceived, Is.EqualTo(0));
+//            
+//            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "helloooo"), testEp);
+//            testLLUDPServer.ReceiveData(null);
+//            
+//            Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(1));
+//            Assert.That(testLLPacketServer.GetPacketsReceivedFor(PacketType.ObjectName), Is.EqualTo(1));
+//        }
+//        
+//        /// <summary>
+//        /// Test that the stack continues to work even if some client has caused a 
+//        /// SocketException on Socket.BeginReceive()
+//        /// </summary>
+//        [Test]
+//        public void TestExceptionOnBeginReceive()
+//        {
+//            TestHelper.InMethod();
+//
+//            MockScene scene = new MockScene();
+//            
+//            uint circuitCodeA = 130000;
+//            EndPoint epA = new IPEndPoint(IPAddress.Loopback, 1300);
+//            UUID agentIdA   = UUID.Parse("00000000-0000-0000-0000-000000001300");
+//            UUID sessionIdA = UUID.Parse("00000000-0000-0000-0000-000000002300");
+//            
+//            uint circuitCodeB = 130001;
+//            EndPoint epB = new IPEndPoint(IPAddress.Loopback, 1301);
+//            UUID agentIdB   = UUID.Parse("00000000-0000-0000-0000-000000001301");
+//            UUID sessionIdB = UUID.Parse("00000000-0000-0000-0000-000000002301");
+//            
+//            TestLLUDPServer testLLUDPServer;
+//            TestLLPacketServer testLLPacketServer;
+//            AgentCircuitManager acm;
+//            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
+//            AddClient(circuitCodeA, epA, agentIdA, sessionIdA, testLLUDPServer, acm);
+//            AddClient(circuitCodeB, epB, agentIdB, sessionIdB, testLLUDPServer, acm);
+//            
+//            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "packet1"), epA);
+//            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "packet2"), epB);
+//            testLLUDPServer.LoadReceiveWithBeginException(epA);
+//            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(2, "packet3"), epB);
+//            testLLUDPServer.ReceiveData(null);
+//            
+//            Assert.IsFalse(testLLUDPServer.HasCircuit(circuitCodeA));
+//         
+//            Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(3));
+//            Assert.That(testLLPacketServer.GetPacketsReceivedFor(PacketType.ObjectName), Is.EqualTo(3));
+//        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/MockScene.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/MockScene.cs
index 34c21aa..fb94355 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/MockScene.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/MockScene.cs
@@ -25,6 +25,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System.Net;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Scenes;
@@ -52,14 +53,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
         public override void Update() {}
         public override void LoadWorldMap() {}
         
-        public override void AddNewClient(IClientAPI client) 
+        public override ISceneAgent AddNewClient(IClientAPI client, PresenceType type)
         {
             client.OnObjectName += RecordObjectNameCall;
+
+            // FIXME
+            return null;
         }
         
-        public override void RemoveClient(UUID agentID) {}
-        public override void CloseAllAgents(uint circuitcode) {}
+        public override void RemoveClient(UUID agentID, bool someReason) {}
+//        public override void CloseAllAgents(uint circuitcode) {}
+        public override bool CheckClient(UUID clientId, IPEndPoint endPoint) { return true; }
         public override void OtherRegionUp(GridRegion otherRegion) {  }
+
+        public override bool TryGetScenePresence(UUID uuid, out ScenePresence sp) { sp = null; return false; }
             
         /// <summary>
         /// Doesn't really matter what the call is - we're using this to test that a packet has actually been received
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
new file mode 100644
index 0000000..0f88ec6
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Tests.Common.Mock;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    /// <summary>
+    /// Tests for the LL packet handler
+    /// </summary>
+    [TestFixture]
+    public class PacketHandlerTests
+    {
+//        [Test]
+//        /// <summary>
+//        /// More a placeholder, really
+//        /// </summary>
+//        public void InPacketTest()
+//        {
+//            TestHelper.InMethod();
+//
+//            AgentCircuitData agent = new AgentCircuitData();
+//            agent.AgentID = UUID.Random();
+//            agent.firstname = "testfirstname";
+//            agent.lastname = "testlastname";
+//            agent.SessionID = UUID.Zero;
+//            agent.SecureSessionID = UUID.Zero;
+//            agent.circuitcode = 123;
+//            agent.BaseFolder = UUID.Zero;
+//            agent.InventoryFolder = UUID.Zero;
+//            agent.startpos = Vector3.Zero;
+//            agent.CapsPath = "http://wibble.com";
+//            
+//            TestLLUDPServer testLLUDPServer;
+//            TestLLPacketServer testLLPacketServer;
+//            AgentCircuitManager acm;
+//            IScene scene = new MockScene();
+//            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
+//
+//            TestClient testClient = new TestClient(agent, scene);
+//            
+//            LLPacketHandler packetHandler
+//                = new LLPacketHandler(testClient, testLLPacketServer, new ClientStackUserSettings());
+//
+//            packetHandler.InPacket(new AgentAnimationPacket());
+//            LLQueItem receivedPacket = packetHandler.PacketQueue.Dequeue();
+//
+//            Assert.That(receivedPacket, Is.Not.Null);
+//            Assert.That(receivedPacket.Incoming, Is.True);
+//            Assert.That(receivedPacket.Packet, Is.TypeOf(typeof(AgentAnimationPacket)));
+//        }
+//
+//        /// <summary>
+//        /// Add a client for testing
+//        /// </summary>
+//        /// <param name="scene"></param>
+//        /// <param name="testLLUDPServer"></param>
+//        /// <param name="testPacketServer"></param>
+//        /// <param name="acm">Agent circuit manager used in setting up the stack</param>
+//        protected void SetupStack(
+//            IScene scene, out TestLLUDPServer testLLUDPServer, out TestLLPacketServer testPacketServer, 
+//            out AgentCircuitManager acm)
+//        {
+//            IConfigSource configSource = new IniConfigSource();
+//            ClientStackUserSettings userSettings = new ClientStackUserSettings();
+//            testLLUDPServer = new TestLLUDPServer();
+//            acm = new AgentCircuitManager();
+//                                    
+//            uint port = 666;
+//            testLLUDPServer.Initialise(null, ref port, 0, false, configSource, acm);
+//            testPacketServer = new TestLLPacketServer(testLLUDPServer, userSettings);
+//            testLLUDPServer.LocalScene = scene;
+//        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs
new file mode 100644
index 0000000..0302385
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using Nini.Config;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.ClientStack.LindenUDP.Tests
+{
+    /// <summary>
+    /// This class enables regression testing of the LLUDPServer by allowing us to intercept outgoing data.
+    /// </summary>
+    public class TestLLUDPServer : LLUDPServer
+    {
+        public List<Packet> PacketsSent { get; private set; }
+
+        public TestLLUDPServer(IPAddress listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port, IConfigSource configSource, AgentCircuitManager circuitManager)
+            : base(listenIP, ref port, proxyPortOffsetParm, allow_alternate_port, configSource, circuitManager)
+        {
+            PacketsSent = new List<Packet>();
+        }
+
+        public override void SendAckImmediate(IPEndPoint remoteEndpoint, PacketAckPacket ack)
+        {
+            PacketsSent.Add(ack);
+        }
+
+        public override void SendPacket(
+            LLUDPClient udpClient, Packet packet, ThrottleOutPacketType category, bool allowSplitting, UnackedPacketMethod method)
+        {
+            PacketsSent.Add(packet);
+        }
+
+////        /// <summary>
+////        /// The chunks of data to pass to the LLUDPServer when it calls EndReceive
+////        /// </summary>
+////        protected Queue<ChunkSenderTuple> m_chunksToLoad = new Queue<ChunkSenderTuple>();
+//        
+////        protected override void BeginReceive()
+////        {
+////            if (m_chunksToLoad.Count > 0 && m_chunksToLoad.Peek().BeginReceiveException)
+////            {
+////                ChunkSenderTuple tuple = m_chunksToLoad.Dequeue();
+////                reusedEpSender = tuple.Sender;
+////                throw new SocketException();
+////            }
+////        }
+//        
+////        protected override bool EndReceive(out int numBytes, IAsyncResult result, ref EndPoint epSender)
+////        {
+////            numBytes = 0;
+////
+////            //m_log.Debug("Queue size " + m_chunksToLoad.Count);
+////            
+////            if (m_chunksToLoad.Count <= 0)
+////                return false;
+////            
+////            ChunkSenderTuple tuple = m_chunksToLoad.Dequeue();
+////            RecvBuffer = tuple.Data;
+////            numBytes   = tuple.Data.Length;
+////            epSender   = tuple.Sender;
+////            
+////            return true;
+////        }
+//        
+////        public override void SendPacketTo(byte[] buffer, int size, SocketFlags flags, uint circuitcode)
+////        {
+////            // Don't do anything just yet
+////        }
+//        
+//        /// <summary>
+//        /// Signal that this chunk should throw an exception on Socket.BeginReceive()
+//        /// </summary>
+//        /// <param name="epSender"></param>
+//        public void LoadReceiveWithBeginException(EndPoint epSender)
+//        {
+//            ChunkSenderTuple tuple = new ChunkSenderTuple(epSender);
+//            tuple.BeginReceiveException = true;
+//            m_chunksToLoad.Enqueue(tuple);
+//        }
+//        
+//        /// <summary>
+//        /// Load some data to be received by the LLUDPServer on the next receive call
+//        /// </summary>
+//        /// <param name="data"></param>
+//        /// <param name="epSender"></param>
+//        public void LoadReceive(byte[] data, EndPoint epSender)
+//        {
+//            m_chunksToLoad.Enqueue(new ChunkSenderTuple(data, epSender));
+//        }
+//        
+//        /// <summary>
+//        /// Load a packet to be received by the LLUDPServer on the next receive call
+//        /// </summary>
+//        /// <param name="packet"></param>
+//        public void LoadReceive(Packet packet, EndPoint epSender)
+//        {
+//            LoadReceive(packet.ToBytes(), epSender);
+//        }
+//        
+//        /// <summary>
+//        /// Calls the protected asynchronous result method.  This fires out all data chunks currently queued for send
+//        /// </summary>
+//        /// <param name="result"></param>
+//        public void ReceiveData(IAsyncResult result)
+//        {
+//            // Doesn't work the same way anymore
+////            while (m_chunksToLoad.Count > 0)
+////                OnReceivedData(result);
+//        }
+    }
+    
+    /// <summary>
+    /// Record the data and sender tuple
+    /// </summary>
+    public class ChunkSenderTuple
+    {
+        public byte[] Data;
+        public EndPoint Sender;
+        public bool BeginReceiveException;
+        
+        public ChunkSenderTuple(byte[] data, EndPoint sender)
+        {
+            Data = data;
+            Sender = sender;
+        }
+        
+        public ChunkSenderTuple(EndPoint sender)
+        {
+            Sender = sender;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs b/OpenSim/Region/ClientStack/Linden/UDP/ThrottleRates.cs
index aaf6e26..c9aac0b 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/ThrottleRates.cs
@@ -52,30 +52,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public int Texture;
         /// <summary>Drip rate for asset packets</summary>
         public int Asset;
-        /// <summary>Drip rate for state packets</summary>
-        public int State;
+
         /// <summary>Drip rate for the parent token bucket</summary>
         public int Total;
 
-        /// <summary>Maximum burst rate for resent packets</summary>
-        public int ResendLimit;
-        /// <summary>Maximum burst rate for land packets</summary>
-        public int LandLimit;
-        /// <summary>Maximum burst rate for wind packets</summary>
-        public int WindLimit;
-        /// <summary>Maximum burst rate for cloud packets</summary>
-        public int CloudLimit;
-        /// <summary>Maximum burst rate for task (state and transaction) packets</summary>
-        public int TaskLimit;
-        /// <summary>Maximum burst rate for texture packets</summary>
-        public int TextureLimit;
-        /// <summary>Maximum burst rate for asset packets</summary>
-        public int AssetLimit;
-        /// <summary>Maximum burst rate for state packets</summary>
-        public int StateLimit;
-        /// <summary>Burst rate for the parent token bucket</summary>
-        public int TotalLimit;
-
+        /// <summary>Flag used to enable adaptive throttles</summary>
+        public bool AdaptiveThrottlesEnabled;
+        
         /// <summary>
         /// Default constructor
         /// </summary>
@@ -86,26 +69,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 IConfig throttleConfig = config.Configs["ClientStack.LindenUDP"];
 
-                Resend = throttleConfig.GetInt("resend_default", 12500);
-                Land = throttleConfig.GetInt("land_default", 1000);
-                Wind = throttleConfig.GetInt("wind_default", 1000);
-                Cloud = throttleConfig.GetInt("cloud_default", 1000);
-                Task = throttleConfig.GetInt("task_default", 1000);
-                Texture = throttleConfig.GetInt("texture_default", 1000);
-                Asset = throttleConfig.GetInt("asset_default", 1000);
-                State = throttleConfig.GetInt("state_default", 1000);
-
-                ResendLimit = throttleConfig.GetInt("resend_limit", 18750);
-                LandLimit = throttleConfig.GetInt("land_limit", 29750);
-                WindLimit = throttleConfig.GetInt("wind_limit", 18750);
-                CloudLimit = throttleConfig.GetInt("cloud_limit", 18750);
-                TaskLimit = throttleConfig.GetInt("task_limit", 18750);
-                TextureLimit = throttleConfig.GetInt("texture_limit", 55750);
-                AssetLimit = throttleConfig.GetInt("asset_limit", 27500);
-                StateLimit = throttleConfig.GetInt("state_limit", 37000);
+                Resend = throttleConfig.GetInt("resend_default", 6625);
+                Land = throttleConfig.GetInt("land_default", 9125);
+                Wind = throttleConfig.GetInt("wind_default", 1750);
+                Cloud = throttleConfig.GetInt("cloud_default", 1750);
+                Task = throttleConfig.GetInt("task_default", 18500);
+                Texture = throttleConfig.GetInt("texture_default", 18500);
+                Asset = throttleConfig.GetInt("asset_default", 10500);
 
                 Total = throttleConfig.GetInt("client_throttle_max_bps", 0);
-                TotalLimit = Total;
+
+                AdaptiveThrottlesEnabled = throttleConfig.GetBoolean("enable_adaptive_throttles", false);
             }
             catch (Exception) { }
         }
@@ -128,34 +102,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     return Texture;
                 case ThrottleOutPacketType.Asset:
                     return Asset;
-                case ThrottleOutPacketType.State:
-                    return State;
-                case ThrottleOutPacketType.Unknown:
-                default:
-                    return 0;
-            }
-        }
-
-        public int GetLimit(ThrottleOutPacketType type)
-        {
-            switch (type)
-            {
-                case ThrottleOutPacketType.Resend:
-                    return ResendLimit;
-                case ThrottleOutPacketType.Land:
-                    return LandLimit;
-                case ThrottleOutPacketType.Wind:
-                    return WindLimit;
-                case ThrottleOutPacketType.Cloud:
-                    return CloudLimit;
-                case ThrottleOutPacketType.Task:
-                    return TaskLimit;
-                case ThrottleOutPacketType.Texture:
-                    return TextureLimit;
-                case ThrottleOutPacketType.Asset:
-                    return AssetLimit;
-                case ThrottleOutPacketType.State:
-                    return StateLimit;
                 case ThrottleOutPacketType.Unknown:
                 default:
                     return 0;
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs b/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
new file mode 100644
index 0000000..4c33db5
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
@@ -0,0 +1,394 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenSim.Framework;
+
+using log4net;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    /// <summary>
+    /// A hierarchical token bucket for bandwidth throttling. See
+    /// http://en.wikipedia.org/wiki/Token_bucket for more information
+    /// </summary>
+    public class TokenBucket
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static Int32 m_counter = 0;
+        
+//        private Int32 m_identifier;
+        
+        /// <summary>
+        /// Number of ticks (ms) per quantum, drip rate and max burst
+        /// are defined over this interval.
+        /// </summary>
+        protected const Int32 m_ticksPerQuantum = 1000;
+
+        /// <summary>
+        /// This is the number of quantums worth of packets that can
+        /// be accommodated during a burst
+        /// </summary>
+        protected const Double m_quantumsPerBurst = 1.5;
+                
+        /// <summary>
+        /// </summary>
+        protected const Int32 m_minimumDripRate = 1400;
+        
+        /// <summary>Time of the last drip, in system ticks</summary>
+        protected Int32 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;
+
+        /// <summary>
+        /// Map of children buckets and their requested maximum burst rate
+        /// </summary>
+        protected Dictionary<TokenBucket,Int64> m_children = new Dictionary<TokenBucket,Int64>();
+        
+#region Properties
+
+        /// <summary>
+        /// The parent bucket of this bucket, or null if this bucket has no
+        /// parent. The parent bucket will limit the aggregate bandwidth of all
+        /// of its children buckets
+        /// </summary>
+        protected TokenBucket m_parent;
+        public TokenBucket Parent
+        {
+            get { return m_parent; }
+            set { m_parent = value; }
+        }
+
+        /// <summary>
+        /// 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 
+        /// also sets the total request for leaf nodes
+        /// </summary>
+        protected Int64 m_burstRate;
+        public Int64 RequestedBurstRate
+        {
+            get { return m_burstRate; }
+            set { m_burstRate = (value < 0 ? 0 : value); }
+        }
+
+        public Int64 BurstRate
+        {
+            get {
+                double rate = RequestedBurstRate * BurstRateModifier();
+                if (rate < m_minimumDripRate * m_quantumsPerBurst)
+                    rate = m_minimumDripRate * m_quantumsPerBurst;
+                
+                return (Int64) rate;
+            }
+        }
+               
+        /// <summary>
+        /// The speed limit of this bucket in bytes per second. This is the
+        /// number of tokens that are added to the bucket per quantum
+        /// </summary>
+        /// <remarks>Tokens are added to the bucket any time 
+        /// <seealso cref="RemoveTokens"/> is called, at the granularity of
+        /// the system tick interval (typically around 15-22ms)</remarks>
+        protected Int64 m_dripRate;
+        public virtual Int64 RequestedDripRate
+        {
+            get { return (m_dripRate == 0 ? m_totalDripRequest : m_dripRate); }
+            set {
+                m_dripRate = (value < 0 ? 0 : value);
+                m_burstRate = (Int64)((double)m_dripRate * m_quantumsPerBurst);
+                m_totalDripRequest = m_dripRate;
+                if (m_parent != null)
+                    m_parent.RegisterRequest(this,m_dripRate);
+            }
+        }
+
+        public virtual Int64 DripRate
+        {
+            get {
+                if (m_parent == null)
+                    return Math.Min(RequestedDripRate,TotalDripRequest);
+                
+                double rate = (double)RequestedDripRate * m_parent.DripRateModifier();
+                if (rate < m_minimumDripRate)
+                    rate = m_minimumDripRate;
+
+                return (Int64)rate;
+            }
+        }
+
+        /// <summary>
+        /// The current total of the requested maximum burst rates of 
+        /// this bucket's children buckets.
+        /// </summary>
+        protected Int64 m_totalDripRequest;
+        public Int64 TotalDripRequest 
+            {
+                get { return m_totalDripRequest; }
+                set { m_totalDripRequest = value; }
+            }
+        
+#endregion Properties
+
+#region Constructor
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="parent">Parent bucket if this is a child bucket, or
+        /// null if this is a root bucket</param>
+        /// <param name="maxBurst">Maximum size of the bucket in bytes, or
+        /// zero if this bucket has no maximum capacity</param>
+        /// <param name="dripRate">Rate that the bucket fills, in bytes per
+        /// second. If zero, the bucket always remains full</param>
+        public TokenBucket(TokenBucket parent, Int64 dripRate) 
+        {
+//            m_identifier = m_counter++;
+            m_counter++;
+
+            Parent = parent;
+            RequestedDripRate = dripRate;
+            // TotalDripRequest = dripRate; // this will be overwritten when a child node registers
+            // MaxBurst = (Int64)((double)dripRate * m_quantumsPerBurst);
+            m_lastDrip = Util.EnvironmentTickCount();
+        }
+
+#endregion Constructor
+
+        /// <summary>
+        /// Compute a modifier for the MaxBurst rate. This is 1.0, meaning
+        /// no modification if the requested bandwidth is less than the
+        /// max burst bandwidth all the way to the root of the throttle
+        /// hierarchy. However, if any of the parents is over-booked, then
+        /// the modifier will be less than 1.
+        /// </summary>
+        protected double DripRateModifier()
+        {
+            Int64 driprate = DripRate;
+            return driprate >= TotalDripRequest ? 1.0 : (double)driprate / (double)TotalDripRequest;
+        }
+
+        /// <summary>
+        /// </summary>
+        protected double BurstRateModifier()
+        {
+            // for now... burst rate is always m_quantumsPerBurst (constant)
+            // larger than drip rate so the ratio of burst requests is the
+            // same as the drip ratio
+            return DripRateModifier();
+        }
+
+        /// <summary>
+        /// Register drip rate requested by a child of this throttle. Pass the
+        /// changes up the hierarchy.
+        /// </summary>
+        public void RegisterRequest(TokenBucket child, Int64 request)
+        {
+            lock (m_children)
+            {
+                m_children[child] = request;
+                // m_totalDripRequest = m_children.Values.Sum();
+
+                m_totalDripRequest = 0;
+                foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
+                    m_totalDripRequest += cref.Value;
+            }
+            
+            // Pass the new values up to the parent
+            if (m_parent != null)
+                m_parent.RegisterRequest(this,Math.Min(RequestedDripRate, TotalDripRequest));
+        }
+
+        /// <summary>
+        /// Remove the rate requested by a child of this throttle. Pass the
+        /// changes up the hierarchy.
+        /// </summary>
+        public void UnregisterRequest(TokenBucket child)
+        {
+            lock (m_children)
+            {
+                m_children.Remove(child);
+                // m_totalDripRequest = m_children.Values.Sum();
+
+                m_totalDripRequest = 0;
+                foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
+                    m_totalDripRequest += cref.Value;
+            }
+            
+
+            // Pass the new values up to the parent
+            if (m_parent != null)
+                m_parent.RegisterRequest(this,Math.Min(RequestedDripRate, TotalDripRequest));
+        }
+        
+        /// <summary>
+        /// Remove 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)
+        {
+            // Deposit tokens for this interval
+            Drip();
+
+            // If we have enough tokens then remove them and return
+            if (m_tokenCount - amount >= 0)
+            {
+                // we don't have to remove from the parent, the drip rate is already
+                // reflective of the drip rate limits in the parent
+                m_tokenCount -= amount;
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <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)
+        {
+            m_tokenCount += count;
+
+            // Deposit the overflow in the parent bucket, this is how we share
+            // unused bandwidth
+            Int64 burstrate = BurstRate;
+            if (m_tokenCount > burstrate)
+                m_tokenCount = burstrate;
+        }
+
+        /// <summary>
+        /// Add tokens to the bucket over time. The number of tokens added each
+        /// call depends on the length of time that has passed since the last 
+        /// call to Drip
+        /// </summary>
+        /// <returns>True if tokens were added to the bucket, otherwise false</returns>
+        protected void Drip()
+        {
+            // This should never happen... means we are a leaf node and were created
+            // with no drip rate...
+            if (DripRate == 0)
+            {
+                m_log.WarnFormat("[TOKENBUCKET] something odd is happening and drip rate is 0");
+                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
+            if (deltaMS <= 0)
+                return;
+
+            Deposit(deltaMS * DripRate / m_ticksPerQuantum);
+        }
+    }
+
+    public class AdaptiveTokenBucket : TokenBucket
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// The minimum rate for flow control. Minimum drip rate is one
+        /// packet per second. Open the throttle to 15 packets per second
+        /// or about 160kbps.
+        /// </summary>
+        protected const Int64 m_minimumFlow = m_minimumDripRate * 15;
+
+        // <summary>
+        // The maximum rate for flow control. Drip rate can never be
+        // greater than this.
+        // </summary>
+        protected Int64 m_maxDripRate = 0;
+        protected Int64 MaxDripRate
+        {
+            get { return (m_maxDripRate == 0 ? m_totalDripRequest : m_maxDripRate); }
+            set { m_maxDripRate = (value == 0 ? 0 : Math.Max(value,m_minimumFlow)); }
+        }
+        
+        private bool m_enabled = false;
+        
+        // <summary>
+        // 
+        // </summary>
+        public virtual Int64 AdjustedDripRate
+        {
+            get { return m_dripRate; }
+            set {
+                m_dripRate = OpenSim.Framework.Util.Clamp<Int64>(value,m_minimumFlow,MaxDripRate);
+                m_burstRate = (Int64)((double)m_dripRate * m_quantumsPerBurst);
+                if (m_parent != null)
+                    m_parent.RegisterRequest(this,m_dripRate);
+            }
+        }
+
+        // <summary>
+        // 
+        // </summary>
+        public AdaptiveTokenBucket(TokenBucket parent, Int64 maxDripRate, bool enabled) : base(parent,maxDripRate)
+        {
+            m_enabled = enabled;
+
+            if (m_enabled)
+            {
+                // m_log.DebugFormat("[TOKENBUCKET] Adaptive throttle enabled");
+                MaxDripRate = maxDripRate;
+                AdjustedDripRate = m_minimumFlow;
+            }
+        }
+                
+        // <summary>
+        // 
+        // </summary>
+        public void ExpirePackets(Int32 count)
+        {
+            // m_log.WarnFormat("[ADAPTIVEBUCKET] drop {0} by {1} expired packets",AdjustedDripRate,count);
+            if (m_enabled)
+                AdjustedDripRate = (Int64) (AdjustedDripRate / Math.Pow(2,count));
+        }
+
+        // <summary>
+        // 
+        // </summary>
+        public void AcknowledgePackets(Int32 count)
+        {
+            if (m_enabled)
+                AdjustedDripRate = AdjustedDripRate + count;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs b/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs
index e43f7cf..9d6c09e 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -28,6 +28,7 @@
 using System;
 using System.Collections.Generic;
 using System.Net;
+using System.Threading;
 using OpenMetaverse;
 
 namespace OpenSim.Region.ClientStack.LindenUDP
@@ -64,7 +65,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>Holds packets that need to be added to the unacknowledged list</summary>
         private LocklessQueue<OutgoingPacket> m_pendingAdds = new LocklessQueue<OutgoingPacket>();
         /// <summary>Holds information about pending acknowledgements</summary>
-        private LocklessQueue<PendingAck> m_pendingRemoves = new LocklessQueue<PendingAck>();
+        private LocklessQueue<PendingAck> m_pendingAcknowledgements = new LocklessQueue<PendingAck>();
+        /// <summary>Holds information about pending removals</summary>
+        private LocklessQueue<uint> m_pendingRemoves = new LocklessQueue<uint>();
 
         /// <summary>
         /// Add an unacked packet to the collection
@@ -77,31 +80,55 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public void Add(OutgoingPacket packet)
         {
             m_pendingAdds.Enqueue(packet);
+            Interlocked.Add(ref packet.Client.UnackedBytes, packet.Buffer.DataLength);            
         }
 
         /// <summary>
         /// Marks a packet as acknowledged
+        /// This method is used when an acknowledgement is received from the network for a previously
+        /// sent packet. Effects of removal this way are to update unacked byte count, adjust RTT
+        /// and increase throttle to the coresponding client.
         /// </summary>
         /// <param name="sequenceNumber">Sequence number of the packet to
         /// acknowledge</param>
         /// <param name="currentTime">Current value of Environment.TickCount</param>
         /// <remarks>This does not immediately acknowledge the packet, it only
         /// queues the ack so it can be handled in a thread-safe way later</remarks>
-        public void Remove(uint sequenceNumber, int currentTime, bool fromResend)
+        public void Acknowledge(uint sequenceNumber, int currentTime, bool fromResend)
         {
-            m_pendingRemoves.Enqueue(new PendingAck(sequenceNumber, currentTime, fromResend));
+            m_pendingAcknowledgements.Enqueue(new PendingAck(sequenceNumber, currentTime, fromResend));
+        }
+
+        /// <summary>
+        /// Marks a packet as no longer needing acknowledgement without a received acknowledgement.
+        /// This method is called when a packet expires and we no longer need an acknowledgement.
+        /// When some reliable packet types expire, they are handled in a way other than simply 
+        /// resending them. The only effect of removal this way is to update unacked byte count.
+        /// </summary>
+        /// <param name="sequenceNumber">Sequence number of the packet to
+        /// acknowledge</param>
+        /// <remarks>The does not immediately remove the packet, it only queues the removal
+        /// so it can be handled in a thread safe way later</remarks>
+        public void Remove(uint sequenceNumber)
+        {
+            m_pendingRemoves.Enqueue(sequenceNumber);
         }
 
         /// <summary>
         /// Returns a list of all of the packets with a TickCount older than
         /// the specified timeout
         /// </summary>
+        /// <remarks>
+        /// This function is not thread safe, and cannot be called
+        /// multiple times concurrently
+        /// </remarks>
         /// <param name="timeoutMS">Number of ticks (milliseconds) before a
-        /// packet is considered expired</param>
-        /// <returns>A list of all expired packets according to the given
-        /// expiration timeout</returns>
-        /// <remarks>This function is not thread safe, and cannot be called
-        /// multiple times concurrently</remarks>
+        /// packet is considered expired
+        /// </param>
+        /// <returns>
+        /// A list of all expired packets according to the given
+        /// expiration timeout
+        /// </returns>
         public List<OutgoingPacket> GetExpiredPackets(int timeoutMS)
         {
             ProcessQueues();
@@ -128,11 +155,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         // is actually sent out again
                         packet.TickCount = 0;
 
+                        // As with other network applications, assume that an expired packet is
+                        // an indication of some network problem, slow transmission
+                        packet.Client.FlowThrottle.ExpirePackets(1);
+                        
                         expiredPackets.Add(packet);
                     }
                 }
             }
 
+                //if (expiredPackets != null)
+                //   m_log.DebugFormat("[UNACKED PACKET COLLECTION]: Found {0} expired packets on timeout of {1}", expiredPackets.Count, timeoutMS);
+
             return expiredPackets;
         }
 
@@ -140,30 +174,59 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             // Process all the pending adds
             OutgoingPacket pendingAdd;
-            while (m_pendingAdds.Dequeue(out pendingAdd))
-                m_packets[pendingAdd.SequenceNumber] = pendingAdd;
-
+            while (m_pendingAdds.TryDequeue(out pendingAdd))
+                if (pendingAdd != null)
+                    m_packets[pendingAdd.SequenceNumber] = pendingAdd;
+            
             // Process all the pending removes, including updating statistics and round-trip times
-            PendingAck pendingRemove;
-            OutgoingPacket ackedPacket;
-            while (m_pendingRemoves.Dequeue(out pendingRemove))
+            PendingAck pendingAcknowledgement;
+            while (m_pendingAcknowledgements.TryDequeue(out pendingAcknowledgement))
             {
-                if (m_packets.TryGetValue(pendingRemove.SequenceNumber, out ackedPacket))
+                //m_log.DebugFormat("[UNACKED PACKET COLLECTION]: Processing ack {0}", pendingAcknowledgement.SequenceNumber);
+                OutgoingPacket ackedPacket;
+                if (m_packets.TryGetValue(pendingAcknowledgement.SequenceNumber, out ackedPacket))
                 {
-                    m_packets.Remove(pendingRemove.SequenceNumber);
-
-                    // Update stats
-                    System.Threading.Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength);
+                    if (ackedPacket != null)
+                    {
+                        m_packets.Remove(pendingAcknowledgement.SequenceNumber);
+
+                        // As with other network applications, assume that an acknowledged packet is an
+                        // indication that the network can handle a little more load, speed up the transmission
+                        ackedPacket.Client.FlowThrottle.AcknowledgePackets(ackedPacket.Buffer.DataLength);
+
+                        // Update stats
+                        Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength);
+
+                        if (!pendingAcknowledgement.FromResend)
+                        {
+                            // Calculate the round-trip time for this packet and its ACK
+                            int rtt = pendingAcknowledgement.RemoveTime - ackedPacket.TickCount;
+                            if (rtt > 0)
+                                ackedPacket.Client.UpdateRoundTrip(rtt);
+                        }
+                    }
+                    else
+                    {
+                         //m_log.WarnFormat("[UNACKED PACKET COLLECTION]: Could not find packet with sequence number {0} to ack", pendingAcknowledgement.SequenceNumber);
+                    }
+                }
+            }
 
-                    if (!pendingRemove.FromResend)
+            uint pendingRemove;
+            while(m_pendingRemoves.TryDequeue(out pendingRemove))
+            {
+                OutgoingPacket removedPacket;
+                if (m_packets.TryGetValue(pendingRemove, out removedPacket))
+                {
+                    if (removedPacket != null)
                     {
-                        // Calculate the round-trip time for this packet and its ACK
-                        int rtt = pendingRemove.RemoveTime - ackedPacket.TickCount;
-                        if (rtt > 0)
-                            ackedPacket.Client.UpdateRoundTrip(rtt);
+                        m_packets.Remove(pendingRemove);
+
+                        // Update stats
+                        Interlocked.Add(ref removedPacket.Client.UnackedBytes, -removedPacket.Buffer.DataLength);
                     }
                 }
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLFileTransfer.cs b/OpenSim/Region/ClientStack/LindenUDP/LLFileTransfer.cs
deleted file mode 100644
index adf171e..0000000
--- a/OpenSim/Region/ClientStack/LindenUDP/LLFileTransfer.cs
+++ /dev/null
@@ -1,365 +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.Generic;
-using OpenMetaverse;
-using OpenSim.Framework;
-
-namespace OpenSim.Region.ClientStack.LindenUDP
-{
-    /// <summary>
-    /// A work in progress, to contain the SL specific file transfer code that is currently in various region modules
-    /// This file currently contains multiple classes that need to be split out into their own files.
-    /// </summary>
-    public class LLFileTransfer : IClientFileTransfer
-    {
-        protected IClientAPI m_clientAPI;
-
-        /// Dictionary of handlers for uploading files from client
-        /// TODO: Need to add cleanup code to remove handlers that have completed their upload
-        protected Dictionary<ulong, XferUploadHandler> m_uploadHandlers;
-        protected object m_uploadHandlersLock = new object();
-
-
-        /// <summary>
-        /// Dictionary of files ready to be sent to clients
-        /// </summary>
-        protected static Dictionary<string, byte[]> m_files;
-
-        /// <summary>
-        /// Dictionary of Download Transfers in progess
-        /// </summary>
-        protected Dictionary<ulong, XferDownloadHandler> m_downloadHandlers = new Dictionary<ulong, XferDownloadHandler>();
-
-
-        public LLFileTransfer(IClientAPI clientAPI)
-        {
-            m_uploadHandlers = new Dictionary<ulong, XferUploadHandler>();
-            m_clientAPI = clientAPI;
-
-            m_clientAPI.OnXferReceive += XferReceive;
-            m_clientAPI.OnAbortXfer += AbortXferUploadHandler;
-        }
-
-        public void Close()
-        {
-            if (m_clientAPI != null)
-            {
-                m_clientAPI.OnXferReceive -= XferReceive;
-                m_clientAPI.OnAbortXfer -= AbortXferUploadHandler;
-                m_clientAPI = null;
-            }
-        }
-
-        #region Upload Handling
-
-        public bool RequestUpload(string clientFileName, UploadComplete uploadCompleteCallback, UploadAborted abortCallback)
-        {
-            if ((String.IsNullOrEmpty(clientFileName)) || (uploadCompleteCallback == null))
-            {
-                return false;
-            }
-
-            XferUploadHandler uploader = new XferUploadHandler(m_clientAPI, clientFileName);
-
-            return StartUpload(uploader, uploadCompleteCallback, abortCallback);
-        }
-
-        public bool RequestUpload(UUID fileID, UploadComplete uploadCompleteCallback, UploadAborted abortCallback)
-        {
-            if ((fileID == UUID.Zero) || (uploadCompleteCallback == null))
-            {
-                return false;
-            }
-
-            XferUploadHandler uploader = new XferUploadHandler(m_clientAPI, fileID);
-
-            return StartUpload(uploader, uploadCompleteCallback, abortCallback);
-        }
-
-        private bool StartUpload(XferUploadHandler uploader, UploadComplete uploadCompleteCallback, UploadAborted abortCallback)
-        {
-            uploader.UploadDone += uploadCompleteCallback;
-            uploader.UploadDone += RemoveXferUploadHandler;
-
-            if (abortCallback != null)
-            {
-                uploader.UploadAborted += abortCallback;
-            }
-
-            lock (m_uploadHandlersLock)
-            {
-                if (!m_uploadHandlers.ContainsKey(uploader.XferID))
-                {
-                    m_uploadHandlers.Add(uploader.XferID, uploader);
-                    uploader.RequestStartXfer(m_clientAPI);
-                    return true;
-                }
-                else
-                {
-                    // something went wrong with the xferID allocation
-                    uploader.UploadDone -= uploadCompleteCallback;
-                    uploader.UploadDone -= RemoveXferUploadHandler;
-                    if (abortCallback != null)
-                    {
-                        uploader.UploadAborted -= abortCallback;
-                    }
-                    return false;
-                }
-            }
-        }
-
-        protected void AbortXferUploadHandler(IClientAPI remoteClient, ulong xferID)
-        {
-            lock (m_uploadHandlersLock)
-            {
-                if (m_uploadHandlers.ContainsKey(xferID))
-                {
-                    m_uploadHandlers[xferID].AbortUpload(remoteClient);
-                    m_uploadHandlers.Remove(xferID);
-                }
-            }
-        }
-
-        protected void XferReceive(IClientAPI remoteClient, ulong xferID, uint packetID, byte[] data)
-        {
-            lock (m_uploadHandlersLock)
-            {
-                if (m_uploadHandlers.ContainsKey(xferID))
-                {
-                    m_uploadHandlers[xferID].XferReceive(remoteClient, xferID, packetID, data);
-                }
-            }
-        }
-
-        protected void RemoveXferUploadHandler(string filename, UUID fileID, ulong transferID, byte[] fileData, IClientAPI remoteClient)
-        {
-
-        }
-        #endregion
-
-    }
-
-    public class XferUploadHandler
-    {
-        private AssetBase m_asset;
-
-        public event UploadComplete UploadDone;
-        public event UploadAborted UploadAborted;
-
-        private sbyte type = 0;
-
-        public ulong mXferID;
-        private UploadComplete handlerUploadDone;
-        private UploadAborted handlerAbort;
-
-        private bool m_complete = false;
-
-        public bool UploadComplete
-        {
-            get { return m_complete; }
-        }
-
-        public XferUploadHandler(IClientAPI pRemoteClient, string pClientFilename)
-        {
-            Initialise(UUID.Zero, pClientFilename);
-        }
-
-        public XferUploadHandler(IClientAPI pRemoteClient, UUID fileID)
-        {
-            Initialise(fileID, String.Empty);
-        }
-
-        private void Initialise(UUID fileID, string fileName)
-        {
-            m_asset = new AssetBase(fileID, fileName, type);
-            m_asset.Data = new byte[0];
-            m_asset.Description = "empty";
-            m_asset.Local = true;
-            m_asset.Temporary = true;
-            mXferID = Util.GetNextXferID();
-        }
-
-        public ulong XferID
-        {
-            get { return mXferID; }
-        }
-
-        public void RequestStartXfer(IClientAPI pRemoteClient)
-        {
-            if (!String.IsNullOrEmpty(m_asset.Name))
-            {
-                pRemoteClient.SendXferRequest(mXferID, m_asset.Type, m_asset.FullID, 0, Utils.StringToBytes(m_asset.Name));
-            }
-            else
-            {
-                pRemoteClient.SendXferRequest(mXferID, m_asset.Type, m_asset.FullID, 0, new byte[0]);
-            }
-        }
-
-        /// <summary>
-        /// Process transfer data received from the client.
-        /// </summary>
-        /// <param name="xferID"></param>
-        /// <param name="packetID"></param>
-        /// <param name="data"></param>
-        public void XferReceive(IClientAPI remoteClient, ulong xferID, uint packetID, byte[] data)
-        {
-            if (mXferID == xferID)
-            {
-                if (m_asset.Data.Length > 1)
-                {
-                    byte[] destinationArray = new byte[m_asset.Data.Length + data.Length];
-                    Array.Copy(m_asset.Data, 0, destinationArray, 0, m_asset.Data.Length);
-                    Array.Copy(data, 0, destinationArray, m_asset.Data.Length, data.Length);
-                    m_asset.Data = destinationArray;
-                }
-                else
-                {
-                    byte[] buffer2 = new byte[data.Length - 4];
-                    Array.Copy(data, 4, buffer2, 0, data.Length - 4);
-                    m_asset.Data = buffer2;
-                }
-
-                remoteClient.SendConfirmXfer(xferID, packetID);
-
-                if ((packetID & 0x80000000) != 0)
-                {
-                    SendCompleteMessage(remoteClient);
-
-                }
-            }
-        }
-
-        protected void SendCompleteMessage(IClientAPI remoteClient)
-        {
-            m_complete = true;
-            handlerUploadDone = UploadDone;
-            if (handlerUploadDone != null)
-            {
-                handlerUploadDone(m_asset.Name, m_asset.FullID, mXferID, m_asset.Data, remoteClient);
-            }
-        }
-
-        public void AbortUpload(IClientAPI remoteClient)
-        {
-            handlerAbort = UploadAborted;
-            if (handlerAbort != null)
-            {
-                handlerAbort(m_asset.Name, m_asset.FullID, mXferID, remoteClient);
-            }
-        }
-    }
-
-    public class XferDownloadHandler
-    {
-        public IClientAPI Client;
-        private bool complete;
-        public byte[] Data = new byte[0];
-        public int DataPointer = 0;
-        public string FileName = String.Empty;
-        public uint Packet = 0;
-        public uint Serial = 1;
-        public ulong XferID = 0;
-
-        public XferDownloadHandler(string fileName, byte[] data, ulong xferID, IClientAPI client)
-        {
-            FileName = fileName;
-            Data = data;
-            XferID = xferID;
-            Client = client;
-        }
-
-        public XferDownloadHandler()
-        {
-        }
-
-        /// <summary>
-        /// Start a transfer
-        /// </summary>
-        /// <returns>True if the transfer is complete, false if not</returns>
-        public bool StartSend()
-        {
-            if (Data.Length < 1000)
-            {
-                // for now (testing) we only support files under 1000 bytes
-                byte[] transferData = new byte[Data.Length + 4];
-                Array.Copy(Utils.IntToBytes(Data.Length), 0, transferData, 0, 4);
-                Array.Copy(Data, 0, transferData, 4, Data.Length);
-                Client.SendXferPacket(XferID, 0 + 0x80000000, transferData);
-
-                complete = true;
-            }
-            else
-            {
-                byte[] transferData = new byte[1000 + 4];
-                Array.Copy(Utils.IntToBytes(Data.Length), 0, transferData, 0, 4);
-                Array.Copy(Data, 0, transferData, 4, 1000);
-                Client.SendXferPacket(XferID, 0, transferData);
-                Packet++;
-                DataPointer = 1000;
-            }
-
-            return complete;
-        }
-
-        /// <summary>
-        /// Respond to an ack packet from the client
-        /// </summary>
-        /// <param name="packet"></param>
-        /// <returns>True if the transfer is complete, false otherwise</returns>
-        public bool AckPacket(uint packet)
-        {
-            if (!complete)
-            {
-                if ((Data.Length - DataPointer) > 1000)
-                {
-                    byte[] transferData = new byte[1000];
-                    Array.Copy(Data, DataPointer, transferData, 0, 1000);
-                    Client.SendXferPacket(XferID, Packet, transferData);
-                    Packet++;
-                    DataPointer += 1000;
-                }
-                else
-                {
-                    byte[] transferData = new byte[Data.Length - DataPointer];
-                    Array.Copy(Data, DataPointer, transferData, 0, Data.Length - DataPointer);
-                    uint endPacket = Packet |= (uint)0x80000000;
-                    Client.SendXferPacket(XferID, endPacket, transferData);
-                    Packet++;
-                    DataPointer += (Data.Length - DataPointer);
-
-                    complete = true;
-                }
-            }
-
-            return complete;
-        }
-    }
-
-}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/BasicCircuitTests.cs b/OpenSim/Region/ClientStack/LindenUDP/Tests/BasicCircuitTests.cs
deleted file mode 100644
index daab84f..0000000
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/BasicCircuitTests.cs
+++ /dev/null
@@ -1,299 +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.Net;
-using log4net.Config;
-using Nini.Config;
-using NUnit.Framework;
-using NUnit.Framework.SyntaxHelpers;
-using OpenMetaverse;
-using OpenMetaverse.Packets;
-using OpenSim.Framework;
-using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
-
-namespace OpenSim.Region.ClientStack.LindenUDP.Tests
-{
-    /// <summary>
-    /// This will contain basic tests for the LindenUDP client stack
-    /// </summary>
-    [TestFixture]
-    public class BasicCircuitTests
-    {
-        [SetUp]
-        public void Init()
-        {
-            try
-            {
-                XmlConfigurator.Configure();
-            }
-            catch
-            {
-                // I don't care, just leave log4net off
-            }
-        }
-        
-        /// <summary>
-        /// Add a client for testing
-        /// </summary>
-        /// <param name="scene"></param>
-        /// <param name="testLLUDPServer"></param>
-        /// <param name="testPacketServer"></param>
-        /// <param name="acm">Agent circuit manager used in setting up the stack</param>
-        protected void SetupStack(
-            IScene scene, out TestLLUDPServer testLLUDPServer, out TestLLPacketServer testPacketServer, 
-            out AgentCircuitManager acm)
-        {
-            IConfigSource configSource = new IniConfigSource();
-            ClientStackUserSettings userSettings = new ClientStackUserSettings();
-            testLLUDPServer = new TestLLUDPServer();
-            acm = new AgentCircuitManager();
-                                    
-            uint port = 666;
-            testLLUDPServer.Initialise(null, ref port, 0, false, configSource, acm);
-            testPacketServer = new TestLLPacketServer(testLLUDPServer, userSettings);
-            testLLUDPServer.LocalScene = scene;
-        }
-        
-        /// <summary>
-        /// Set up a client for tests which aren't concerned with this process itself and where only one client is being
-        /// tested
-        /// </summary>
-        /// <param name="circuitCode"></param>
-        /// <param name="epSender"></param>
-        /// <param name="testLLUDPServer"></param>
-        /// <param name="acm"></param>
-        protected void AddClient(
-            uint circuitCode, EndPoint epSender, TestLLUDPServer testLLUDPServer, AgentCircuitManager acm)
-        {
-            UUID myAgentUuid   = UUID.Parse("00000000-0000-0000-0000-000000000001");
-            UUID mySessionUuid = UUID.Parse("00000000-0000-0000-0000-000000000002");
-            
-            AddClient(circuitCode, epSender, myAgentUuid, mySessionUuid, testLLUDPServer, acm);
-        }
-        
-        /// <summary>
-        /// Set up a client for tests which aren't concerned with this process itself
-        /// </summary>
-        /// <param name="circuitCode"></param>
-        /// <param name="epSender"></param>
-        /// <param name="agentId"></param>
-        /// <param name="sessionId"></param>
-        /// <param name="testLLUDPServer"></param>
-        /// <param name="acm"></param>
-        protected void AddClient(
-            uint circuitCode, EndPoint epSender, UUID agentId, UUID sessionId, 
-            TestLLUDPServer testLLUDPServer, AgentCircuitManager acm)
-        {
-            AgentCircuitData acd = new AgentCircuitData();
-            acd.AgentID = agentId;
-            acd.SessionID = sessionId; 
-            
-            UseCircuitCodePacket uccp = new UseCircuitCodePacket();
-            
-            UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock 
-                = new UseCircuitCodePacket.CircuitCodeBlock();
-            uccpCcBlock.Code = circuitCode;
-            uccpCcBlock.ID = agentId;
-            uccpCcBlock.SessionID = sessionId;
-            uccp.CircuitCode = uccpCcBlock;
-
-            acm.AddNewCircuit(circuitCode, acd);
-            
-            testLLUDPServer.LoadReceive(uccp, epSender);
-            testLLUDPServer.ReceiveData(null);
-        }
-        
-        /// <summary>
-        /// Build an object name packet for test purposes
-        /// </summary>
-        /// <param name="objectLocalId"></param>
-        /// <param name="objectName"></param>
-        protected ObjectNamePacket BuildTestObjectNamePacket(uint objectLocalId, string objectName)
-        {
-            ObjectNamePacket onp = new ObjectNamePacket();
-            ObjectNamePacket.ObjectDataBlock odb = new ObjectNamePacket.ObjectDataBlock();
-            odb.LocalID = objectLocalId;
-            odb.Name = Utils.StringToBytes(objectName);
-            onp.ObjectData = new ObjectNamePacket.ObjectDataBlock[] { odb };
-            onp.Header.Zerocoded = false;
-            
-            return onp;
-        }
-        
-        /// <summary>
-        /// Test adding a client to the stack
-        /// </summary>
-        [Test, LongRunning]
-        public void TestAddClient()
-        {
-            TestHelper.InMethod();
-
-            uint myCircuitCode = 123456;
-            UUID myAgentUuid   = UUID.Parse("00000000-0000-0000-0000-000000000001");
-            UUID mySessionUuid = UUID.Parse("00000000-0000-0000-0000-000000000002");
-            
-            TestLLUDPServer testLLUDPServer;
-            TestLLPacketServer testLLPacketServer;
-            AgentCircuitManager acm;
-            SetupStack(new MockScene(), out testLLUDPServer, out testLLPacketServer, out acm);
-            
-            AgentCircuitData acd = new AgentCircuitData();
-            acd.AgentID = myAgentUuid;
-            acd.SessionID = mySessionUuid;
-            
-            UseCircuitCodePacket uccp = new UseCircuitCodePacket();
-            
-            UseCircuitCodePacket.CircuitCodeBlock uccpCcBlock 
-                = new UseCircuitCodePacket.CircuitCodeBlock();
-            uccpCcBlock.Code = myCircuitCode;
-            uccpCcBlock.ID = myAgentUuid;
-            uccpCcBlock.SessionID = mySessionUuid;
-            uccp.CircuitCode = uccpCcBlock;
-            
-            EndPoint testEp = new IPEndPoint(IPAddress.Loopback, 999);
-            
-            testLLUDPServer.LoadReceive(uccp, testEp);
-            testLLUDPServer.ReceiveData(null);
-            
-            // Circuit shouildn't exist since the circuit manager doesn't know about this circuit for authentication yet
-            Assert.IsFalse(testLLUDPServer.HasCircuit(myCircuitCode));
-                        
-            acm.AddNewCircuit(myCircuitCode, acd);
-            
-            testLLUDPServer.LoadReceive(uccp, testEp);
-            testLLUDPServer.ReceiveData(null);
-            
-            // Should succeed now
-            Assert.IsTrue(testLLUDPServer.HasCircuit(myCircuitCode));
-            Assert.IsFalse(testLLUDPServer.HasCircuit(101));
-        }
-
-        /// <summary>
-        /// Test removing a client from the stack
-        /// </summary>
-        [Test]
-        public void TestRemoveClient()
-        {
-            TestHelper.InMethod();
-
-            uint myCircuitCode = 123457;
-            
-            TestLLUDPServer testLLUDPServer;
-            TestLLPacketServer testLLPacketServer;
-            AgentCircuitManager acm;
-            SetupStack(new MockScene(), out testLLUDPServer, out testLLPacketServer, out acm);
-            AddClient(myCircuitCode, new IPEndPoint(IPAddress.Loopback, 1000), testLLUDPServer, acm);
-            
-            testLLUDPServer.RemoveClientCircuit(myCircuitCode);
-            Assert.IsFalse(testLLUDPServer.HasCircuit(myCircuitCode));
-            
-            // Check that removing a non-existant circuit doesn't have any bad effects
-            testLLUDPServer.RemoveClientCircuit(101);
-            Assert.IsFalse(testLLUDPServer.HasCircuit(101));
-        }
-        
-        /// <summary>
-        /// Make sure that the client stack reacts okay to malformed packets
-        /// </summary>
-        [Test]
-        public void TestMalformedPacketSend()
-        {
-            TestHelper.InMethod();
-
-            uint myCircuitCode = 123458;
-            EndPoint testEp = new IPEndPoint(IPAddress.Loopback, 1001);
-            MockScene scene = new MockScene(); 
-            
-            TestLLUDPServer testLLUDPServer;
-            TestLLPacketServer testLLPacketServer;
-            AgentCircuitManager acm;
-            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
-            AddClient(myCircuitCode, testEp, testLLUDPServer, acm);
-
-            byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };
-
-            // Send two garbled 'packets' in succession
-            testLLUDPServer.LoadReceive(data, testEp);
-            testLLUDPServer.LoadReceive(data, testEp);
-            testLLUDPServer.ReceiveData(null); 
-            
-            // Check that we are still here
-            Assert.IsTrue(testLLUDPServer.HasCircuit(myCircuitCode));
-            Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(0));
-            
-            // Check that sending a valid packet to same circuit still succeeds
-            Assert.That(scene.ObjectNameCallsReceived, Is.EqualTo(0));
-            
-            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "helloooo"), testEp);
-            testLLUDPServer.ReceiveData(null);
-            
-            Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(1));
-            Assert.That(testLLPacketServer.GetPacketsReceivedFor(PacketType.ObjectName), Is.EqualTo(1));
-        }
-        
-        /// <summary>
-        /// Test that the stack continues to work even if some client has caused a 
-        /// SocketException on Socket.BeginReceive()
-        /// </summary>
-        [Test]
-        public void TestExceptionOnBeginReceive()
-        {
-            TestHelper.InMethod();
-
-            MockScene scene = new MockScene();
-            
-            uint circuitCodeA = 130000;
-            EndPoint epA = new IPEndPoint(IPAddress.Loopback, 1300);
-            UUID agentIdA   = UUID.Parse("00000000-0000-0000-0000-000000001300");
-            UUID sessionIdA = UUID.Parse("00000000-0000-0000-0000-000000002300");
-            
-            uint circuitCodeB = 130001;
-            EndPoint epB = new IPEndPoint(IPAddress.Loopback, 1301);
-            UUID agentIdB   = UUID.Parse("00000000-0000-0000-0000-000000001301");
-            UUID sessionIdB = UUID.Parse("00000000-0000-0000-0000-000000002301");
-            
-            TestLLUDPServer testLLUDPServer;
-            TestLLPacketServer testLLPacketServer;
-            AgentCircuitManager acm;
-            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
-            AddClient(circuitCodeA, epA, agentIdA, sessionIdA, testLLUDPServer, acm);
-            AddClient(circuitCodeB, epB, agentIdB, sessionIdB, testLLUDPServer, acm);
-            
-            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "packet1"), epA);
-            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(1, "packet2"), epB);
-            testLLUDPServer.LoadReceiveWithBeginException(epA);
-            testLLUDPServer.LoadReceive(BuildTestObjectNamePacket(2, "packet3"), epB);
-            testLLUDPServer.ReceiveData(null);
-            
-            Assert.IsFalse(testLLUDPServer.HasCircuit(circuitCodeA));
-         
-            Assert.That(testLLPacketServer.GetTotalPacketsReceived(), Is.EqualTo(3));
-            Assert.That(testLLPacketServer.GetPacketsReceivedFor(PacketType.ObjectName), Is.EqualTo(3));
-        }
-    }
-}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/PacketHandlerTests.cs b/OpenSim/Region/ClientStack/LindenUDP/Tests/PacketHandlerTests.cs
deleted file mode 100644
index 7d0757f..0000000
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/PacketHandlerTests.cs
+++ /dev/null
@@ -1,106 +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 Nini.Config;
-using NUnit.Framework;
-using NUnit.Framework.SyntaxHelpers;
-using OpenMetaverse;
-using OpenMetaverse.Packets;
-using OpenSim.Framework;
-using OpenSim.Tests.Common.Mock;
-using OpenSim.Tests.Common;
-
-namespace OpenSim.Region.ClientStack.LindenUDP.Tests
-{
-    /// <summary>
-    /// Tests for the LL packet handler
-    /// </summary>
-    [TestFixture]
-    public class PacketHandlerTests
-    {
-        [Test]
-        /// <summary>
-        /// More a placeholder, really
-        /// </summary>
-        public void InPacketTest()
-        {
-            TestHelper.InMethod();
-
-            AgentCircuitData agent = new AgentCircuitData();
-            agent.AgentID = UUID.Random();
-            agent.firstname = "testfirstname";
-            agent.lastname = "testlastname";
-            agent.SessionID = UUID.Zero;
-            agent.SecureSessionID = UUID.Zero;
-            agent.circuitcode = 123;
-            agent.BaseFolder = UUID.Zero;
-            agent.InventoryFolder = UUID.Zero;
-            agent.startpos = Vector3.Zero;
-            agent.CapsPath = "http://wibble.com";
-            
-            TestLLUDPServer testLLUDPServer;
-            TestLLPacketServer testLLPacketServer;
-            AgentCircuitManager acm;
-            IScene scene = new MockScene();
-            SetupStack(scene, out testLLUDPServer, out testLLPacketServer, out acm);
-            
-            TestClient testClient = new TestClient(agent, scene);
-            
-            LLPacketHandler packetHandler 
-                = new LLPacketHandler(testClient, testLLPacketServer, new ClientStackUserSettings());
-            
-            packetHandler.InPacket(new AgentAnimationPacket());
-            LLQueItem receivedPacket = packetHandler.PacketQueue.Dequeue();
-            
-            Assert.That(receivedPacket, Is.Not.Null);
-            Assert.That(receivedPacket.Incoming, Is.True);
-            Assert.That(receivedPacket.Packet, Is.TypeOf(typeof(AgentAnimationPacket)));
-        }
-        
-        /// <summary>
-        /// Add a client for testing
-        /// </summary>
-        /// <param name="scene"></param>
-        /// <param name="testLLUDPServer"></param>
-        /// <param name="testPacketServer"></param>
-        /// <param name="acm">Agent circuit manager used in setting up the stack</param>
-        protected void SetupStack(
-            IScene scene, out TestLLUDPServer testLLUDPServer, out TestLLPacketServer testPacketServer, 
-            out AgentCircuitManager acm)
-        {
-            IConfigSource configSource = new IniConfigSource();
-            ClientStackUserSettings userSettings = new ClientStackUserSettings();
-            testLLUDPServer = new TestLLUDPServer();
-            acm = new AgentCircuitManager();
-                                    
-            uint port = 666;
-            testLLUDPServer.Initialise(null, ref port, 0, false, configSource, acm);
-            testPacketServer = new TestLLPacketServer(testLLUDPServer, userSettings);
-            testLLUDPServer.LocalScene = scene;
-        }
-    }
-}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/TestLLUDPServer.cs b/OpenSim/Region/ClientStack/LindenUDP/Tests/TestLLUDPServer.cs
deleted file mode 100644
index f98586d..0000000
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/TestLLUDPServer.cs
+++ /dev/null
@@ -1,153 +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.Generic;
-using System.Net;
-using System.Net.Sockets;
-using OpenMetaverse.Packets;
-
-namespace OpenSim.Region.ClientStack.LindenUDP.Tests
-{
-    /// <summary>
-    /// This class enables synchronous testing of the LLUDPServer by allowing us to load our own data into the end 
-    /// receive event
-    /// </summary>
-    public class TestLLUDPServer : LLUDPServer
-    {
-        /// <summary>
-        /// The chunks of data to pass to the LLUDPServer when it calls EndReceive
-        /// </summary>
-        protected Queue<ChunkSenderTuple> m_chunksToLoad = new Queue<ChunkSenderTuple>();
-        
-        protected override void BeginReceive()
-        {
-            if (m_chunksToLoad.Count > 0 && m_chunksToLoad.Peek().BeginReceiveException)
-            {
-                ChunkSenderTuple tuple = m_chunksToLoad.Dequeue();
-                reusedEpSender = tuple.Sender;
-                throw new SocketException();
-            }
-        }
-        
-        protected override bool EndReceive(out int numBytes, IAsyncResult result, ref EndPoint epSender)
-        {
-            numBytes = 0;
-
-            //m_log.Debug("Queue size " + m_chunksToLoad.Count);
-            
-            if (m_chunksToLoad.Count <= 0)
-                return false;
-            
-            ChunkSenderTuple tuple = m_chunksToLoad.Dequeue();
-            RecvBuffer = tuple.Data;
-            numBytes   = tuple.Data.Length;
-            epSender   = tuple.Sender;
-            
-            return true;
-        }
-        
-        public override void SendPacketTo(byte[] buffer, int size, SocketFlags flags, uint circuitcode) 
-        {
-            // Don't do anything just yet
-        }
-        
-        /// <summary>
-        /// Signal that this chunk should throw an exception on Socket.BeginReceive()
-        /// </summary>
-        /// <param name="epSender"></param>
-        public void LoadReceiveWithBeginException(EndPoint epSender)
-        {
-            ChunkSenderTuple tuple = new ChunkSenderTuple(epSender);
-            tuple.BeginReceiveException = true;
-            m_chunksToLoad.Enqueue(tuple);
-        }
-        
-        /// <summary>
-        /// Load some data to be received by the LLUDPServer on the next receive call
-        /// </summary>
-        /// <param name="data"></param>
-        /// <param name="epSender"></param>
-        public void LoadReceive(byte[] data, EndPoint epSender)
-        {
-            m_chunksToLoad.Enqueue(new ChunkSenderTuple(data, epSender));
-        }
-        
-        /// <summary>
-        /// Load a packet to be received by the LLUDPServer on the next receive call
-        /// </summary>
-        /// <param name="packet"></param>
-        public void LoadReceive(Packet packet, EndPoint epSender)
-        {
-            LoadReceive(packet.ToBytes(), epSender);
-        }
-        
-        /// <summary>
-        /// Calls the protected asynchronous result method.  This fires out all data chunks currently queued for send
-        /// </summary>
-        /// <param name="result"></param>
-        public void ReceiveData(IAsyncResult result)
-        {
-            while (m_chunksToLoad.Count > 0)
-                OnReceivedData(result);
-        }
-        
-        /// <summary>
-        /// Has a circuit with the given code been established?
-        /// </summary>
-        /// <param name="circuitCode"></param>
-        /// <returns></returns>
-        public bool HasCircuit(uint circuitCode)
-        {
-            lock (clientCircuits_reverse)
-            {
-                return clientCircuits_reverse.ContainsKey(circuitCode);
-            }
-        }
-    }
-    
-    /// <summary>
-    /// Record the data and sender tuple
-    /// </summary>
-    public class ChunkSenderTuple
-    {
-        public byte[] Data;
-        public EndPoint Sender;
-        public bool BeginReceiveException;
-        
-        public ChunkSenderTuple(byte[] data, EndPoint sender)
-        {
-            Data = data;
-            Sender = sender;
-        }
-        
-        public ChunkSenderTuple(EndPoint sender)
-        {
-            Sender = sender;
-        }
-    }
-}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/TokenBucket.cs b/OpenSim/Region/ClientStack/LindenUDP/TokenBucket.cs
deleted file mode 100644
index bdbd284..0000000
--- a/OpenSim/Region/ClientStack/LindenUDP/TokenBucket.cs
+++ /dev/null
@@ -1,217 +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;
-
-namespace OpenSim.Region.ClientStack.LindenUDP
-{
-    /// <summary>
-    /// A hierarchical token bucket for bandwidth throttling. See
-    /// http://en.wikipedia.org/wiki/Token_bucket for more information
-    /// </summary>
-    public class TokenBucket
-    {
-        /// <summary>Parent bucket to this bucket, or null if this is a root
-        /// bucket</summary>
-        TokenBucket parent;
-        /// <summary>Size of the bucket in bytes. If zero, the bucket has 
-        /// infinite capacity</summary>
-        int maxBurst;
-        /// <summary>Rate that the bucket fills, in bytes per millisecond. If
-        /// zero, the bucket always remains full</summary>
-        int tokensPerMS;
-        /// <summary>Number of tokens currently in the bucket</summary>
-        int content;
-        /// <summary>Time of the last drip, in system ticks</summary>
-        int lastDrip;
-
-        #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 { return parent; }
-        }
-
-        /// <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
-        /// </summary>
-        public int MaxBurst
-        {
-            get { return maxBurst; }
-            set { maxBurst = (value >= 0 ? value : 0); }
-        }
-
-        /// <summary>
-        /// The speed limit of this bucket in bytes per second. This is the
-        /// number of tokens that are added to the bucket per second
-        /// </summary>
-        /// <remarks>Tokens are added to the bucket any time 
-        /// <seealso cref="RemoveTokens"/> is called, at the granularity of
-        /// the system tick interval (typically around 15-22ms)</remarks>
-        public int DripRate
-        {
-            get { return tokensPerMS * 1000; }
-            set
-            {
-                if (value == 0)
-                    tokensPerMS = 0;
-                else
-                {
-                    int bpms = (int)((float)value / 1000.0f);
-
-                    if (bpms <= 0)
-                        tokensPerMS = 1; // 1 byte/ms is the minimum granularity
-                    else
-                        tokensPerMS = bpms;
-                }
-            }
-        }
-
-        /// <summary>
-        /// The speed limit of this bucket in bytes per millisecond
-        /// </summary>
-        public int DripPerMS
-        {
-            get { return tokensPerMS; }
-        }
-
-        /// <summary>
-        /// The number of bytes that can be sent at this moment. This is the
-        /// current number of tokens in the bucket
-        /// <remarks>If this bucket has a parent bucket that does not have
-        /// enough tokens for a request, <seealso cref="RemoveTokens"/> will 
-        /// return false regardless of the content of this bucket</remarks>
-        /// </summary>
-        public int Content
-        {
-            get { return content; }
-        }
-
-        #endregion Properties
-
-        /// <summary>
-        /// Default constructor
-        /// </summary>
-        /// <param name="parent">Parent bucket if this is a child bucket, or
-        /// null if this is a root bucket</param>
-        /// <param name="maxBurst">Maximum size of the bucket in bytes, or
-        /// zero if this bucket has no maximum capacity</param>
-        /// <param name="dripRate">Rate that the bucket fills, in bytes per
-        /// second. If zero, the bucket always remains full</param>
-        public TokenBucket(TokenBucket parent, int maxBurst, int dripRate)
-        {
-            this.parent = parent;
-            MaxBurst = maxBurst;
-            DripRate = dripRate;
-            lastDrip = Environment.TickCount & Int32.MaxValue;
-        }
-
-        /// <summary>
-        /// Remove a given number of tokens from the bucket
-        /// </summary>
-        /// <param name="amount">Number of tokens to remove from the bucket</param>
-        /// <returns>True if the requested number of tokens were removed from
-        /// the bucket, otherwise false</returns>
-        public bool RemoveTokens(int amount)
-        {
-            bool dummy;
-            return RemoveTokens(amount, out dummy);
-        }
-
-        /// <summary>
-        /// Remove a given number of tokens from the bucket
-        /// </summary>
-        /// <param name="amount">Number of tokens to remove from the bucket</param>
-        /// <param name="dripSucceeded">True if tokens were added to the bucket
-        /// during this call, otherwise false</param>
-        /// <returns>True if the requested number of tokens were removed from
-        /// the bucket, otherwise false</returns>
-        public bool RemoveTokens(int amount, out bool dripSucceeded)
-        {
-            if (maxBurst == 0)
-            {
-                dripSucceeded = true;
-                return true;
-            }
-
-            dripSucceeded = Drip();
-
-            if (content - amount >= 0)
-            {
-                if (parent != null && !parent.RemoveTokens(amount))
-                    return false;
-
-                content -= amount;
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        /// <summary>
-        /// Add tokens to the bucket over time. The number of tokens added each
-        /// call depends on the length of time that has passed since the last 
-        /// call to Drip
-        /// </summary>
-        /// <returns>True if tokens were added to the bucket, otherwise false</returns>
-        public bool Drip()
-        {
-            if (tokensPerMS == 0)
-            {
-                content = maxBurst;
-                return true;
-            }
-            else
-            {
-                int now = Environment.TickCount & Int32.MaxValue;
-                int deltaMS = now - lastDrip;
-
-                if (deltaMS <= 0)
-                {
-                    if (deltaMS < 0)
-                        lastDrip = now;
-                    return false;
-                }
-
-                int dripAmount = deltaMS * tokensPerMS;
-
-                content = Math.Min(content + dripAmount, maxBurst);
-                lastDrip = now;
-
-                return true;
-            }
-        }
-    }
-}
diff --git a/OpenSim/Region/ClientStack/RegionApplicationBase.cs b/OpenSim/Region/ClientStack/RegionApplicationBase.cs
index e57e298..6e3a58e 100644
--- a/OpenSim/Region/ClientStack/RegionApplicationBase.cs
+++ b/OpenSim/Region/ClientStack/RegionApplicationBase.cs
@@ -36,6 +36,7 @@ using OpenSim.Framework.Communications;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Physics.Manager;
 
@@ -48,30 +49,16 @@ namespace OpenSim.Region.ClientStack
 
         protected Dictionary<EndPoint, uint> m_clientCircuits = new Dictionary<EndPoint, uint>();
         protected NetworkServersInfo m_networkServersInfo;
-
-        public NetworkServersInfo NetServersInfo
-        {
-            get { return m_networkServersInfo; }
-        }
-
         protected uint m_httpServerPort;
-        
-        public CommunicationsManager CommunicationsManager 
-        {
-            get { return m_commsManager; }
-            set { m_commsManager = value; }
-        }
-        protected CommunicationsManager m_commsManager;
-
-        protected StorageManager m_storageManager;
-        
+        protected ISimulationDataService m_simulationDataService;
+        protected IEstateDataService m_estateDataService;
         protected ClientStackManager m_clientStackManager;
-
-        public SceneManager SceneManager
-        {
-            get { return m_sceneManager; }
-        }
         protected SceneManager m_sceneManager = new SceneManager();
+
+        public SceneManager SceneManager { get { return m_sceneManager; } }
+        public NetworkServersInfo NetServersInfo { get { return m_networkServersInfo; } }
+        public ISimulationDataService SimulationDataService { get { return m_simulationDataService; } }
+        public IEstateDataService EstateDataService { get { return m_estateDataService; } }
        
         protected abstract void Initialize();
         
@@ -85,15 +72,11 @@ namespace OpenSim.Region.ClientStack
         /// <returns></returns>
         protected abstract PhysicsScene GetPhysicsScene(string osSceneIdentifier);
         
-        protected abstract StorageManager CreateStorageManager();
         protected abstract ClientStackManager CreateClientStackManager();
-        protected abstract Scene CreateScene(RegionInfo regionInfo, StorageManager storageManager,
-                                             AgentCircuitManager circuitManager);
+        protected abstract Scene CreateScene(RegionInfo regionInfo, ISimulationDataService simDataService, IEstateDataService estateDataService, AgentCircuitManager circuitManager);
 
         protected override void StartupSpecific()
         {
-            m_storageManager = CreateStorageManager();
-
             m_clientStackManager = CreateClientStackManager();
 
             Initialize();
@@ -111,6 +94,24 @@ namespace OpenSim.Region.ClientStack
             m_log.InfoFormat("[REGION SERVER]: Starting HTTP server on port {0}", m_httpServerPort);
             m_httpServer.Start();
 
+            MainServer.Instance = m_httpServer;
+
+            // "OOB" Server
+            if (m_networkServersInfo.ssl_listener)
+            {
+                BaseHttpServer server = null;
+                server = new BaseHttpServer(
+                    m_networkServersInfo.https_port, m_networkServersInfo.ssl_listener, m_networkServersInfo.cert_path,
+                    m_networkServersInfo.cert_pass);
+                // Add the server to m_Servers
+                if(server != null)
+                {
+                    m_log.InfoFormat("[REGION SERVER]: Starting HTTPS server on port {0}", server.Port);
+                    MainServer.AddHttpServer(server);
+                    server.Start();
+                }
+            }
+
             base.StartupSpecific();
         }