40 files changed, 1345 insertions, 1679 deletions
diff --git a/OpenSim/Client/MXP/ClientStack/MXPClientView.cs b/OpenSim/Client/MXP/ClientStack/MXPClientView.cs
index bc1b2e5..bc02bc4 100644
--- a/OpenSim/Client/MXP/ClientStack/MXPClientView.cs
+++ b/OpenSim/Client/MXP/ClientStack/MXPClientView.cs
@@ -774,6 +774,11 @@ namespace OpenSim.Client.MXP.ClientStack
            get { return m_sessionID.CRC(); }
        }
+        public IPEndPoint RemoteEndPoint
+        {
+            get { return Session.RemoteEndPoint; }
+        }
        public void SetDebugPacketLevel(int newDebug)
        {
            //m_debugLevel = newDebug;
@@ -798,9 +803,9 @@ namespace OpenSim.Client.MXP.ClientStack
                OnConnectionClosed(this);
        }
-        public void Close(bool ShutdownCircuit)
+        public void Close()
        {
-            m_log.Info("[MXP ClientStack] Close Called with SC=" + ShutdownCircuit);
+            m_log.Info("[MXP ClientStack] Close Called");
            // Tell the client to go
            SendLogoutPacket();
@@ -815,7 +820,7 @@ namespace OpenSim.Client.MXP.ClientStack
        public void Kick(string message)
        {
-            Close(false);
+            Close();
        }
        public void Start()
@@ -1448,7 +1453,7 @@ namespace OpenSim.Client.MXP.ClientStack
        public void Terminate()
        {
-            Close(false);
+            Close();
        }
        public void SendSetFollowCamProperties(UUID objectID, SortedDictionary<int, float> parameters)
@@ -1615,12 +1620,12 @@ namespace OpenSim.Client.MXP.ClientStack
        public void Disconnect(string reason)
        {
            Kick(reason);
-            Close(true);
+            Close();
        }
        public void Disconnect()
        {
-            Close(true);
+            Close();
        }
        #endregion
diff --git a/OpenSim/Client/MXP/PacketHandler/MXPPacketServer.cs b/OpenSim/Client/MXP/PacketHandler/MXPPacketServer.cs
index 4910ab1..ba9c653 100644
--- a/OpenSim/Client/MXP/PacketHandler/MXPPacketServer.cs
+++ b/OpenSim/Client/MXP/PacketHandler/MXPPacketServer.cs
@@ -339,12 +339,6 @@ namespace OpenSim.Client.MXP.PacketHandler
                                m_clients.Add(client);
                                m_log.Debug("[MXP ClientStack]: Created ClientView.");
-                                m_log.Debug("[MXP ClientStack]: Adding ClientView to Scene...");
-                                scene.ClientManager.Add(client.CircuitCode, client);
-                                m_log.Debug("[MXP ClientStack]: Added ClientView to Scene.");
                                client.MXPSendSynchronizationBegin(m_scenes[new UUID(joinRequestMessage.BubbleId)].SceneContents.GetTotalObjectsCount());
                                m_log.Debug("[MXP ClientStack]: Starting ClientView...");
diff --git a/OpenSim/Client/VWoHTTP/ClientStack/VWHClientView.cs b/OpenSim/Client/VWoHTTP/ClientStack/VWHClientView.cs
index c649c5a..e3abcf5 100644
--- a/OpenSim/Client/VWoHTTP/ClientStack/VWHClientView.cs
+++ b/OpenSim/Client/VWoHTTP/ClientStack/VWHClientView.cs
@@ -207,6 +207,11 @@ namespace OpenSim.Client.VWoHTTP.ClientStack
            get { throw new System.NotImplementedException(); }
        }
+        public IPEndPoint RemoteEndPoint
+        {
+            get { throw new System.NotImplementedException(); }
+        }
        public event GenericMessage OnGenericMessage = delegate { };
        public event ImprovedInstantMessage OnInstantMessage = delegate { };
        public event ChatMessage OnChatFromClient = delegate { };
@@ -415,7 +420,7 @@ namespace OpenSim.Client.VWoHTTP.ClientStack
            throw new System.NotImplementedException();
        }
-        public void Close(bool ShutdownCircuit)
+        public void Close()
        {
            throw new System.NotImplementedException();
        }
diff --git a/OpenSim/Framework/ClientManager.cs b/OpenSim/Framework/ClientManager.cs
index 094a3ff..61b59e7 100644
--- a/OpenSim/Framework/ClientManager.cs
+++ b/OpenSim/Framework/ClientManager.cs
@@ -28,193 +28,195 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using log4net;
+using System.Net;
 using OpenMetaverse;
 using OpenMetaverse.Packets;
 namespace OpenSim.Framework
 {
-    public delegate void ForEachClientDelegate(IClientAPI client);
+    /// <summary>
+    /// Maps from client AgentID and RemoteEndPoint values to IClientAPI
+    /// references for all of the connected clients
+    /// </summary>
    public class ClientManager
    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        /// <summary>A dictionary mapping from <seealso cref="UUID"/>
+        /// to <seealso cref="IClientAPI"/> references</summary>
-        private Dictionary<uint, IClientAPI> m_clients;
+        private Dictionary<UUID, IClientAPI> m_dict1;
+        /// <summary>A dictionary mapping from <seealso cref="IPEndPoint"/>
+        /// to <seealso cref="IClientAPI"/> references</summary>
+        private Dictionary<IPEndPoint, IClientAPI> m_dict2;
+        /// <summary>An immutable collection of <seealso cref="IClientAPI"/>
+        /// references</summary>
+        private IClientAPI[] m_array;
+        /// <summary>Synchronization object for writing to the collections</summary>
+        private object m_syncRoot = new object();
+        /// <summary>Number of clients in the collection</summary>
+        public int Count { get { return m_dict1.Count; } }
+        /// <summary>
+        /// Default constructor
+        /// </summary>
        public ClientManager()
        {
-            m_clients = new Dictionary<uint, IClientAPI>();
+            m_dict1 = new Dictionary<UUID, IClientAPI>();
+            m_dict2 = new Dictionary<IPEndPoint, IClientAPI>();
+            m_array = new IClientAPI[0];
        }
-        public void ForEachClient(ForEachClientDelegate whatToDo)
+        /// <summary>
+        /// Add a client reference to the collection if it does not already
+        /// exist
+        /// </summary>
+        /// <param name="value">Reference to the client object</param>
+        /// <returns>True if the client reference was successfully added,
+        /// otherwise false if the given key already existed in the collection</returns>
+        public bool Add(IClientAPI value)
        {
-            IClientAPI[] LocalClients;
+            lock (m_syncRoot)
-            lock (m_clients)
            {
-                LocalClients = new IClientAPI[m_clients.Count];
+                if (m_dict1.ContainsKey(value.AgentId) || m_dict2.ContainsKey(value.RemoteEndPoint))
-                m_clients.Values.CopyTo(LocalClients, 0);
+                    return false;
-            }
-            for (int i = 0; i < LocalClients.Length; i++)
+                m_dict1[value.AgentId] = value;
-            {
+                m_dict2[value.RemoteEndPoint] = value;
-                try
-                {
-                    whatToDo(LocalClients[i]);
-                }
-                catch (Exception e)
-                {
-                    m_log.Warn("[CLIENT]: Unable to do ForEachClient for one of the clients" + "\n Reason: " + e.ToString());
-                }
-            }
-        }
-        public void Remove(uint id)
+                IClientAPI[] oldArray = m_array;
-        {
+                int oldLength = oldArray.Length;
-            lock (m_clients)
-            {
-                m_clients.Remove(id);
-            }
-        }
-        public void Add(uint id, IClientAPI client)
+                IClientAPI[] newArray = new IClientAPI[oldLength + 1];
-        {
+                for (int i = 0; i < oldLength; i++)
-            lock (m_clients)
+                    newArray[i] = oldArray[i];
-            {
+                newArray[oldLength] = value;
-                m_clients.Add(id, client);
+                m_array = newArray;
            }
+            return true;
        }
        /// <summary>
-        /// Pass incoming packet to client.
+        /// Remove a client from the collection
        /// </summary>
-        /// <param name="circuitCode">uint identifying the connection/client.</param>
+        /// <param name="key">UUID of the client to remove</param>
-        /// <param name="packet">object containing the packet.</param>
+        /// <returns>True if a client was removed, or false if the given UUID
-        public void InPacket(uint circuitCode, object packet)
+        /// was not present in the collection</returns>
-        {
+        public bool Remove(UUID key)
-            IClientAPI client;
-            bool tryGetRet = false;
-            
-            lock (m_clients)
-                tryGetRet = m_clients.TryGetValue(circuitCode, out client);
-            
-            if (tryGetRet)
-            {
-                client.InPacket(packet);
-            }
-        }
-        public void CloseAllAgents(uint circuitCode)
        {
-            IClientAPI client;
+            lock (m_syncRoot)
-            bool tryGetRet = false;
-            lock (m_clients)
-                tryGetRet = m_clients.TryGetValue(circuitCode, out client);
-            if (tryGetRet)
            {
-                CloseAllCircuits(client.AgentId);
+                IClientAPI value;
-            }
+                if (m_dict1.TryGetValue(key, out value))
-        }
+                {
+                    m_dict1.Remove(key);
+                    m_dict2.Remove(value.RemoteEndPoint);
-        public void CloseAllCircuits(UUID agentId)
+                    IClientAPI[] oldArray = m_array;
-        {
+                    int oldLength = oldArray.Length;
-            uint[] circuits = GetAllCircuits(agentId);
-            // We're using a for loop here so changes to the circuits don't cause it to completely fail.
-            for (int i = 0; i < circuits.Length; i++)
+                    IClientAPI[] newArray = new IClientAPI[oldLength - 1];
-            {
+                    int j = 0;
-                IClientAPI client;
+                    for (int i = 0; i < oldLength; i++)
-                try
-                {
-                    bool tryGetRet = false;
-                    lock (m_clients)
-                        tryGetRet = m_clients.TryGetValue(circuits[i], out client);
-                    if (tryGetRet)
                    {
-                        Remove(client.CircuitCode);
+                        if (oldArray[i] != value)
-                        client.Close(false);
+                            newArray[j++] = oldArray[i];
                    }
-                }
-                catch (Exception e)
+                    m_array = newArray;
-                {
+                    return true;
-                    m_log.Error(string.Format("[CLIENT]: Unable to shutdown circuit for: {0}\n Reason: {1}", agentId, e));
                }
            }
+            return false;
        }
-        // [Obsolete("Using Obsolete to drive development is invalid.  Obsolete presumes that something new has already been created to replace this.")]
+        /// <summary>
-        public uint[] GetAllCircuits(UUID agentId)
+        /// Resets the client collection
+        /// </summary>
+        public void Clear()
        {
-            List<uint> circuits = new List<uint>();
+            lock (m_syncRoot)
-            // Wasteful, I know
-            IClientAPI[] LocalClients = new IClientAPI[0];
-            lock (m_clients)
            {
-                LocalClients = new IClientAPI[m_clients.Count];
+                m_dict1.Clear();
-                m_clients.Values.CopyTo(LocalClients, 0);
+                m_dict2.Clear();
+                m_array = new IClientAPI[0];
            }
-            for (int i = 0; i < LocalClients.Length; i++)
-            {
-                if (LocalClients[i].AgentId == agentId)
-                {
-                    circuits.Add(LocalClients[i].CircuitCode);
-                }
-            }
-            return circuits.ToArray();
        }
-        public List<uint> GetAllCircuitCodes()
+        /// <summary>
+        /// Checks if a UUID is in the collection
+        /// </summary>
+        /// <param name="key">UUID to check for</param>
+        /// <returns>True if the UUID was found in the collection, otherwise false</returns>
+        public bool ContainsKey(UUID key)
        {
-            List<uint> circuits;
+            return m_dict1.ContainsKey(key);
+        }
-            lock (m_clients)
-            {
-                circuits = new List<uint>(m_clients.Keys);
-            }
-            return circuits;
+        /// <summary>
+        /// Checks if an endpoint is in the collection
+        /// </summary>
+        /// <param name="key">Endpoint to check for</param>
+        /// <returns>True if the endpoint was found in the collection, otherwise false</returns>
+        public bool ContainsKey(IPEndPoint key)
+        {
+            return m_dict2.ContainsKey(key);
        }
-        public void ViewerEffectHandler(IClientAPI sender, List<ViewerEffectEventHandlerArg> args)
+        /// <summary>
+        /// Attempts to fetch a value out of the collection
+        /// </summary>
+        /// <param name="key">UUID of the client to retrieve</param>
+        /// <param name="value">Retrieved client, or null on lookup failure</param>
+        /// <returns>True if the lookup succeeded, otherwise false</returns>
+        public bool TryGetValue(UUID key, out IClientAPI value)
        {
-            // TODO: don't create new blocks if recycling an old packet
+            try { return m_dict1.TryGetValue(key, out value); }
-            List<ViewerEffectPacket.EffectBlock> effectBlock = new List<ViewerEffectPacket.EffectBlock>();
+            catch (Exception)
-            for (int i = 0; i < args.Count; i++)
            {
-                ViewerEffectPacket.EffectBlock effect = new ViewerEffectPacket.EffectBlock();
+                value = null;
-                effect.AgentID = args[i].AgentID;
+                return false;
-                effect.Color = args[i].Color;
-                effect.Duration = args[i].Duration;
-                effect.ID = args[i].ID;
-                effect.Type = args[i].Type;
-                effect.TypeData = args[i].TypeData;
-                effectBlock.Add(effect);
            }
-            ViewerEffectPacket.EffectBlock[] effectBlockArray = effectBlock.ToArray();
+        }
-            IClientAPI[] LocalClients;
+        /// <summary>
-            lock (m_clients)
+        /// Attempts to fetch a value out of the collection
+        /// </summary>
+        /// <param name="key">Endpoint of the client to retrieve</param>
+        /// <param name="value">Retrieved client, or null on lookup failure</param>
+        /// <returns>True if the lookup succeeded, otherwise false</returns>
+        public bool TryGetValue(IPEndPoint key, out IClientAPI value)
+        {
+            try { return m_dict2.TryGetValue(key, out value); }
+            catch (Exception)
            {
-                LocalClients = new IClientAPI[m_clients.Count];
+                value = null;
-                m_clients.Values.CopyTo(LocalClients, 0);
+                return false;
            }
+        }
-            for (int i = 0; i < LocalClients.Length; i++)
+        /// <summary>
-            {
+        /// Performs a given task in parallel for each of the elements in the
-                if (LocalClients[i].AgentId != sender.AgentId)
+        /// collection
-                {
+        /// </summary>
-                    LocalClients[i].SendViewerEffect(effectBlockArray);
+        /// <param name="action">Action to perform on each element</param>
-                }
+        public void ForEach(Action<IClientAPI> action)
-            }
+        {
+            IClientAPI[] localArray = m_array;
+            Parallel.ForEach<IClientAPI>(localArray, action);
        }
-        public bool TryGetClient(uint circuitId, out IClientAPI user)
+        /// <summary>
+        /// Performs a given task synchronously for each of the elements in
+        /// the collection
+        /// </summary>
+        /// <param name="action">Action to perform on each element</param>
+        public void ForEachSync(Action<IClientAPI> action)
        {
-            lock (m_clients)
+            IClientAPI[] localArray = m_array;
-            {
+            for (int i = 0; i < localArray.Length; i++)
-                return m_clients.TryGetValue(circuitId, out user);
+                action(localArray[i]);
-            }
        }
    }
 }
diff --git a/OpenSim/Framework/Communications/GenericAsyncResult.cs b/OpenSim/Framework/Communications/GenericAsyncResult.cs
index efd2f43..8e3f62b 100644
--- a/OpenSim/Framework/Communications/GenericAsyncResult.cs
+++ b/OpenSim/Framework/Communications/GenericAsyncResult.cs
@@ -146,6 +146,7 @@ namespace OpenSim.Framework.Communications
                // If the operation isn't done, wait for it
                AsyncWaitHandle.WaitOne();
                AsyncWaitHandle.Close();
+                m_waitHandle.Close();
                m_waitHandle = null; // Allow early GC
            }
diff --git a/OpenSim/Framework/Communications/RestClient.cs b/OpenSim/Framework/Communications/RestClient.cs
index d98f47d..a74169e 100644
--- a/OpenSim/Framework/Communications/RestClient.cs
+++ b/OpenSim/Framework/Communications/RestClient.cs
@@ -105,7 +105,7 @@ namespace OpenSim.Framework.Communications
        /// <summary>
        /// This flag will help block the main synchroneous method, in case we run in synchroneous mode
        /// </summary>
-        public static ManualResetEvent _allDone = new ManualResetEvent(false);
+        //public static ManualResetEvent _allDone = new ManualResetEvent(false);
        /// <summary>
        /// Default time out period
@@ -282,12 +282,12 @@ namespace OpenSim.Framework.Communications
                else
                {
                    s.Close();
-                    _allDone.Set();
+                    //_allDone.Set();
                }
            }
            catch (Exception e)
            {
-                _allDone.Set();
+                //_allDone.Set();
                _asyncException = e;
            }
        }
diff --git a/OpenSim/Framework/IClientAPI.cs b/OpenSim/Framework/IClientAPI.cs
index d3bd9e7..29846f5 100644
--- a/OpenSim/Framework/IClientAPI.cs
+++ b/OpenSim/Framework/IClientAPI.cs
@@ -561,6 +561,8 @@ namespace OpenSim.Framework
        // [Obsolete("LLClientView Specific - Circuits are unique to LLClientView")]
        uint CircuitCode { get; }
+        IPEndPoint RemoteEndPoint { get; }
        event GenericMessage OnGenericMessage;
        // [Obsolete("LLClientView Specific - Replace with more bare-bones arguments.")]
@@ -802,7 +804,7 @@ namespace OpenSim.Framework
        void InPacket(object NewPack);
        void ProcessInPacket(Packet NewPack);
-        void Close(bool ShutdownCircuit);
+        void Close();
        void Kick(string message);
        
        /// <summary>
diff --git a/OpenSim/Framework/IScene.cs b/OpenSim/Framework/IScene.cs
index 489653f..f34027d 100644
--- a/OpenSim/Framework/IScene.cs
+++ b/OpenSim/Framework/IScene.cs
@@ -71,7 +71,6 @@ namespace OpenSim.Framework
        void AddNewClient(IClientAPI client);
        void RemoveClient(UUID agentID);
-        void CloseAllAgents(uint circuitcode);
        void Restart(int seconds);
        //RegionInfo OtherRegionUp(RegionInfo thisRegion);
diff --git a/OpenSim/Framework/LocklessQueue.cs b/OpenSim/Framework/LocklessQueue.cs
new file mode 100644
index 0000000..dd3d201
--- /dev/null
+++ b/OpenSim/Framework/LocklessQueue.cs
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2009, openmetaverse.org
+ * All rights reserved.
+ *
+ * - Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * - Neither the name of the openmetaverse.org nor the names
+ *   of its contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Threading;
+namespace OpenSim.Framework
+{
+    public sealed class LocklessQueue<T>
+    {
+        private sealed class SingleLinkNode
+        {
+            public SingleLinkNode Next;
+            public T Item;
+        }
+        SingleLinkNode head;
+        SingleLinkNode tail;
+        int count;
+        public int Count { get { return count; } }
+        public LocklessQueue()
+        {
+            Init();
+        }
+        public void Enqueue(T item)
+        {
+            SingleLinkNode oldTail = null;
+            SingleLinkNode oldTailNext;
+            SingleLinkNode newNode = new SingleLinkNode();
+            newNode.Item = item;
+            bool newNodeWasAdded = false;
+            while (!newNodeWasAdded)
+            {
+                oldTail = tail;
+                oldTailNext = oldTail.Next;
+                if (tail == oldTail)
+                {
+                    if (oldTailNext == null)
+                        newNodeWasAdded = CAS(ref tail.Next, null, newNode);
+                    else
+                        CAS(ref tail, oldTail, oldTailNext);
+                }
+            }
+            CAS(ref tail, oldTail, newNode);
+            Interlocked.Increment(ref count);
+        }
+        public bool Dequeue(out T item)
+        {
+            item = default(T);
+            SingleLinkNode oldHead = null;
+            bool haveAdvancedHead = false;
+            while (!haveAdvancedHead)
+            {
+                oldHead = head;
+                SingleLinkNode oldTail = tail;
+                SingleLinkNode oldHeadNext = oldHead.Next;
+                if (oldHead == head)
+                {
+                    if (oldHead == oldTail)
+                    {
+                        if (oldHeadNext == null)
+                            return false;
+                        CAS(ref tail, oldTail, oldHeadNext);
+                    }
+                    else
+                    {
+                        item = oldHeadNext.Item;
+                        haveAdvancedHead = CAS(ref head, oldHead, oldHeadNext);
+                    }
+                }
+            }
+            Interlocked.Decrement(ref count);
+            return true;
+        }
+        public void Clear()
+        {
+            Init();
+        }
+        private void Init()
+        {
+            count = 0;
+            head = tail = new SingleLinkNode();
+        }
+        private static bool CAS(ref SingleLinkNode location, SingleLinkNode comparand, SingleLinkNode newValue)
+        {
+            return
+                (object)comparand ==
+                (object)Interlocked.CompareExchange<SingleLinkNode>(ref location, newValue, comparand);
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Framework/Parallel.cs b/OpenSim/Framework/Parallel.cs
index 74537ba..6efdad0 100644
--- a/OpenSim/Framework/Parallel.cs
+++ b/OpenSim/Framework/Parallel.cs
@@ -89,6 +89,7 @@ namespace OpenSim.Framework
            }
            threadFinishEvent.WaitOne();
+            threadFinishEvent.Close();
            if (exception != null)
                throw new Exception(exception.Message, exception);
@@ -148,6 +149,7 @@ namespace OpenSim.Framework
            }
            threadFinishEvent.WaitOne();
+            threadFinishEvent.Close();
            if (exception != null)
                throw new Exception(exception.Message, exception);
@@ -199,6 +201,7 @@ namespace OpenSim.Framework
            }
            threadFinishEvent.WaitOne();
+            threadFinishEvent.Close();
            if (exception != null)
                throw new Exception(exception.Message, exception);
diff --git a/OpenSim/Framework/ThrottleOutPacketType.cs b/OpenSim/Framework/ThrottleOutPacketType.cs
index fd490a5..e21ff32 100644
--- a/OpenSim/Framework/ThrottleOutPacketType.cs
+++ b/OpenSim/Framework/ThrottleOutPacketType.cs
@@ -31,13 +31,24 @@ namespace OpenSim.Framework
 {
    public enum ThrottleOutPacketType : int
    {
-        Unknown = -1, // Also doubles as 'do not throttle'
+        /// <summary>Unthrottled packets</summary>
+        Unknown = -1,
+        /// <summary>Packets that are being resent</summary>
        Resend = 0,
+        /// <summary>Terrain data</summary>
        Land = 1,
+        /// <summary>Wind data</summary>
        Wind = 2,
+        /// <summary>Cloud data</summary>
        Cloud = 3,
+        /// <summary>Any packets that do not fit into the other throttles</summary>
        Task = 4,
+        /// <summary>Texture assets</summary>
        Texture = 5,
+        /// <summary>Non-texture assets</summary>
        Asset = 6,
+        /// <summary>Avatar and primitive data</summary>
+        /// <remarks>This is a sub-category of Task</remarks>
+        State = 7,
    }
 }
diff --git a/OpenSim/Region/Application/OpenSim.cs b/OpenSim/Region/Application/OpenSim.cs
index 4d8409bb..ca6a2a3 100644
--- a/OpenSim/Region/Application/OpenSim.cs
+++ b/OpenSim/Region/Application/OpenSim.cs
@@ -239,6 +239,10 @@ namespace OpenSim
                                          "show users [full]",
                                          "Show user data", HandleShow);
+            m_console.Commands.AddCommand("region", false, "show connections",
+                                          "show connections",
+                                          "Show connection data", HandleShow);
            m_console.Commands.AddCommand("region", false, "show users full",
                                          "show users full",
                                          String.Empty, HandleShow);
@@ -921,7 +925,25 @@ namespace OpenSim
                                regionName));
                    }
-                    m_log.Info("");
+                    m_log.Info(String.Empty);
+                    break;
+                case "connections":
+                    System.Text.StringBuilder connections = new System.Text.StringBuilder("Connections:\n");
+                    m_sceneManager.ForEachScene(
+                        delegate(Scene scene)
+                        {
+                            scene.ClientManager.ForEachSync(
+                                delegate(IClientAPI client)
+                                {
+                                    connections.AppendFormat("{0}: {1} ({2}) from {3} on circuit {4}\n",
+                                        scene.RegionInfo.RegionName, client.Name, client.AgentId, client.RemoteEndPoint, client.CircuitCode);
+                                }
+                            );
+                        }
+                    );
+                    m_log.Info(connections.ToString());
                    break;
                case "modules":
diff --git a/OpenSim/Region/Application/OpenSimBackground.cs b/OpenSim/Region/Application/OpenSimBackground.cs
index ac5e241..008c6b0 100644
--- a/OpenSim/Region/Application/OpenSimBackground.cs
+++ b/OpenSim/Region/Application/OpenSimBackground.cs
@@ -58,6 +58,7 @@ namespace OpenSim
                             m_clientServers.Count.ToString(), m_clientServers.Count > 1 ? "s" : "");
            WorldHasComeToAnEnd.WaitOne();
+            WorldHasComeToAnEnd.Close();
        }
        /// <summary>
diff --git a/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs b/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs
index bb98f24..b53a2fb 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs
@@ -75,14 +75,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            m_imageManager = imageManager;
        }
-        public bool SendPackets(LLClientView client, int maxpack)
+        /// <summary>
+        /// Sends packets for this texture to a client until packetsToSend is 
+        /// hit or the transfer completes
+        /// </summary>
+        /// <param name="client">Reference to the client that the packets are destined for</param>
+        /// <param name="packetsToSend">Maximum number of packets to send during this call</param>
+        /// <param name="packetsSent">Number of packets sent during this call</param>
+        /// <returns>True if the transfer completes at the current discard level, otherwise false</returns>
+        public bool SendPackets(LLClientView client, int packetsToSend, out int packetsSent)
        {
-            if (client == null)
+            packetsSent = 0;
-                return false;
            if (m_currentPacket <= m_stopPacket)
            {
-                int count = 0;
                bool sendMore = true;
                if (!m_sentInfo || (m_currentPacket == 0))
@@ -91,25 +97,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                    m_sentInfo = true;
                    ++m_currentPacket;
-                    ++count;
+                    ++packetsSent;
                }
                if (m_currentPacket < 2)
                {
                    m_currentPacket = 2;
                }
                
-                while (sendMore && count < maxpack && m_currentPacket <= m_stopPacket)
+                while (sendMore && packetsSent < packetsToSend && m_currentPacket <= m_stopPacket)
                {
                    sendMore = SendPacket(client);
                    ++m_currentPacket;
-                    ++count;
+                    ++packetsSent;
                }
-                if (m_currentPacket > m_stopPacket)
-                    return true;
            }
-            return false;
+            return (m_currentPacket > m_stopPacket);
        }
        public void RunUpdate()
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index d64f655..8487adc 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -59,6 +59,209 @@ namespace OpenSim.Region.ClientStack.LindenUDP
    /// </summary>
    public class LLClientView : IClientAPI, IClientCore, IClientIM, IClientChat, IClientIPEndpoint, IStatsCollector
    {
+        #region Events
+        public event GenericMessage OnGenericMessage;
+        public event BinaryGenericMessage OnBinaryGenericMessage;
+        public event Action<IClientAPI> OnLogout;
+        public event ObjectPermissions OnObjectPermissions;
+        public event Action<IClientAPI> OnConnectionClosed;
+        public event ViewerEffectEventHandler OnViewerEffect;
+        public event ImprovedInstantMessage OnInstantMessage;
+        public event ChatMessage OnChatFromClient;
+        public event TextureRequest OnRequestTexture;
+        public event RezObject OnRezObject;
+        public event DeRezObject OnDeRezObject;
+        public event ModifyTerrain OnModifyTerrain;
+        public event Action<IClientAPI> OnRegionHandShakeReply;
+        public event GenericCall2 OnRequestWearables;
+        public event SetAppearance OnSetAppearance;
+        public event AvatarNowWearing OnAvatarNowWearing;
+        public event RezSingleAttachmentFromInv OnRezSingleAttachmentFromInv;
+        public event RezMultipleAttachmentsFromInv OnRezMultipleAttachmentsFromInv;
+        public event UUIDNameRequest OnDetachAttachmentIntoInv;
+        public event ObjectAttach OnObjectAttach;
+        public event ObjectDeselect OnObjectDetach;
+        public event ObjectDrop OnObjectDrop;
+        public event GenericCall2 OnCompleteMovementToRegion;
+        public event UpdateAgent OnAgentUpdate;
+        public event AgentRequestSit OnAgentRequestSit;
+        public event AgentSit OnAgentSit;
+        public event AvatarPickerRequest OnAvatarPickerRequest;
+        public event StartAnim OnStartAnim;
+        public event StopAnim OnStopAnim;
+        public event Action<IClientAPI> OnRequestAvatarsData;
+        public event LinkObjects OnLinkObjects;
+        public event DelinkObjects OnDelinkObjects;
+        public event GrabObject OnGrabObject;
+        public event DeGrabObject OnDeGrabObject;
+        public event SpinStart OnSpinStart;
+        public event SpinStop OnSpinStop;
+        public event ObjectDuplicate OnObjectDuplicate;
+        public event ObjectDuplicateOnRay OnObjectDuplicateOnRay;
+        public event MoveObject OnGrabUpdate;
+        public event SpinObject OnSpinUpdate;
+        public event AddNewPrim OnAddPrim;
+        public event RequestGodlikePowers OnRequestGodlikePowers;
+        public event GodKickUser OnGodKickUser;
+        public event ObjectExtraParams OnUpdateExtraParams;
+        public event UpdateShape OnUpdatePrimShape;
+        public event ObjectRequest OnObjectRequest;
+        public event ObjectSelect OnObjectSelect;
+        public event ObjectDeselect OnObjectDeselect;
+        public event GenericCall7 OnObjectDescription;
+        public event GenericCall7 OnObjectName;
+        public event GenericCall7 OnObjectClickAction;
+        public event GenericCall7 OnObjectMaterial;
+        public event ObjectIncludeInSearch OnObjectIncludeInSearch;
+        public event RequestObjectPropertiesFamily OnRequestObjectPropertiesFamily;
+        public event UpdatePrimFlags OnUpdatePrimFlags;
+        public event UpdatePrimTexture OnUpdatePrimTexture;
+        public event UpdateVector OnUpdatePrimGroupPosition;
+        public event UpdateVector OnUpdatePrimSinglePosition;
+        public event UpdatePrimRotation OnUpdatePrimGroupRotation;
+        public event UpdatePrimSingleRotation OnUpdatePrimSingleRotation;
+        public event UpdatePrimSingleRotationPosition OnUpdatePrimSingleRotationPosition;
+        public event UpdatePrimGroupRotation OnUpdatePrimGroupMouseRotation;
+        public event UpdateVector OnUpdatePrimScale;
+        public event UpdateVector OnUpdatePrimGroupScale;
+        public event StatusChange OnChildAgentStatus;
+        public event GenericCall2 OnStopMovement;
+        public event Action<UUID> OnRemoveAvatar;
+        public event RequestMapBlocks OnRequestMapBlocks;
+        public event RequestMapName OnMapNameRequest;
+        public event TeleportLocationRequest OnTeleportLocationRequest;
+        public event TeleportLandmarkRequest OnTeleportLandmarkRequest;
+        public event DisconnectUser OnDisconnectUser;
+        public event RequestAvatarProperties OnRequestAvatarProperties;
+        public event SetAlwaysRun OnSetAlwaysRun;
+        public event FetchInventory OnAgentDataUpdateRequest;
+        public event TeleportLocationRequest OnSetStartLocationRequest;
+        public event UpdateAvatarProperties OnUpdateAvatarProperties;
+        public event CreateNewInventoryItem OnCreateNewInventoryItem;
+        public event CreateInventoryFolder OnCreateNewInventoryFolder;
+        public event UpdateInventoryFolder OnUpdateInventoryFolder;
+        public event MoveInventoryFolder OnMoveInventoryFolder;
+        public event FetchInventoryDescendents OnFetchInventoryDescendents;
+        public event PurgeInventoryDescendents OnPurgeInventoryDescendents;
+        public event FetchInventory OnFetchInventory;
+        public event RequestTaskInventory OnRequestTaskInventory;
+        public event UpdateInventoryItem OnUpdateInventoryItem;
+        public event CopyInventoryItem OnCopyInventoryItem;
+        public event MoveInventoryItem OnMoveInventoryItem;
+        public event RemoveInventoryItem OnRemoveInventoryItem;
+        public event RemoveInventoryFolder OnRemoveInventoryFolder;
+        public event UDPAssetUploadRequest OnAssetUploadRequest;
+        public event XferReceive OnXferReceive;
+        public event RequestXfer OnRequestXfer;
+        public event ConfirmXfer OnConfirmXfer;
+        public event AbortXfer OnAbortXfer;
+        public event RequestTerrain OnRequestTerrain;
+        public event RezScript OnRezScript;
+        public event UpdateTaskInventory OnUpdateTaskInventory;
+        public event MoveTaskInventory OnMoveTaskItem;
+        public event RemoveTaskInventory OnRemoveTaskItem;
+        public event RequestAsset OnRequestAsset;
+        public event UUIDNameRequest OnNameFromUUIDRequest;
+        public event ParcelAccessListRequest OnParcelAccessListRequest;
+        public event ParcelAccessListUpdateRequest OnParcelAccessListUpdateRequest;
+        public event ParcelPropertiesRequest OnParcelPropertiesRequest;
+        public event ParcelDivideRequest OnParcelDivideRequest;
+        public event ParcelJoinRequest OnParcelJoinRequest;
+        public event ParcelPropertiesUpdateRequest OnParcelPropertiesUpdateRequest;
+        public event ParcelSelectObjects OnParcelSelectObjects;
+        public event ParcelObjectOwnerRequest OnParcelObjectOwnerRequest;
+        public event ParcelAbandonRequest OnParcelAbandonRequest;
+        public event ParcelGodForceOwner OnParcelGodForceOwner;
+        public event ParcelReclaim OnParcelReclaim;
+        public event ParcelReturnObjectsRequest OnParcelReturnObjectsRequest;
+        public event ParcelDeedToGroup OnParcelDeedToGroup;
+        public event RegionInfoRequest OnRegionInfoRequest;
+        public event EstateCovenantRequest OnEstateCovenantRequest;
+        public event FriendActionDelegate OnApproveFriendRequest;
+        public event FriendActionDelegate OnDenyFriendRequest;
+        public event FriendshipTermination OnTerminateFriendship;
+        public event MoneyTransferRequest OnMoneyTransferRequest;
+        public event EconomyDataRequest OnEconomyDataRequest;
+        public event MoneyBalanceRequest OnMoneyBalanceRequest;
+        public event ParcelBuy OnParcelBuy;
+        public event UUIDNameRequest OnTeleportHomeRequest;
+        public event UUIDNameRequest OnUUIDGroupNameRequest;
+        public event ScriptAnswer OnScriptAnswer;
+        public event RequestPayPrice OnRequestPayPrice;
+        public event ObjectSaleInfo OnObjectSaleInfo;
+        public event ObjectBuy OnObjectBuy;
+        public event BuyObjectInventory OnBuyObjectInventory;
+        public event AgentSit OnUndo;
+        public event ForceReleaseControls OnForceReleaseControls;
+        public event GodLandStatRequest OnLandStatRequest;
+        public event RequestObjectPropertiesFamily OnObjectGroupRequest;
+        public event DetailedEstateDataRequest OnDetailedEstateDataRequest;
+        public event SetEstateFlagsRequest OnSetEstateFlagsRequest;
+        public event SetEstateTerrainBaseTexture OnSetEstateTerrainBaseTexture;
+        public event SetEstateTerrainDetailTexture OnSetEstateTerrainDetailTexture;
+        public event SetEstateTerrainTextureHeights OnSetEstateTerrainTextureHeights;
+        public event CommitEstateTerrainTextureRequest OnCommitEstateTerrainTextureRequest;
+        public event SetRegionTerrainSettings OnSetRegionTerrainSettings;
+        public event BakeTerrain OnBakeTerrain;
+        public event RequestTerrain OnUploadTerrain;
+        public event EstateChangeInfo OnEstateChangeInfo;
+        public event EstateRestartSimRequest OnEstateRestartSimRequest;
+        public event EstateChangeCovenantRequest OnEstateChangeCovenantRequest;
+        public event UpdateEstateAccessDeltaRequest OnUpdateEstateAccessDeltaRequest;
+        public event SimulatorBlueBoxMessageRequest OnSimulatorBlueBoxMessageRequest;
+        public event EstateBlueBoxMessageRequest OnEstateBlueBoxMessageRequest;
+        public event EstateDebugRegionRequest OnEstateDebugRegionRequest;
+        public event EstateTeleportOneUserHomeRequest OnEstateTeleportOneUserHomeRequest;
+        public event EstateTeleportAllUsersHomeRequest OnEstateTeleportAllUsersHomeRequest;
+        public event RegionHandleRequest OnRegionHandleRequest;
+        public event ParcelInfoRequest OnParcelInfoRequest;
+        public event ScriptReset OnScriptReset;
+        public event GetScriptRunning OnGetScriptRunning;
+        public event SetScriptRunning OnSetScriptRunning;
+        public event UpdateVector OnAutoPilotGo;
+        public event TerrainUnacked OnUnackedTerrain;
+        public event ActivateGesture OnActivateGesture;
+        public event DeactivateGesture OnDeactivateGesture;
+        public event ObjectOwner OnObjectOwner;
+        public event DirPlacesQuery OnDirPlacesQuery;
+        public event DirFindQuery OnDirFindQuery;
+        public event DirLandQuery OnDirLandQuery;
+        public event DirPopularQuery OnDirPopularQuery;
+        public event DirClassifiedQuery OnDirClassifiedQuery;
+        public event EventInfoRequest OnEventInfoRequest;
+        public event ParcelSetOtherCleanTime OnParcelSetOtherCleanTime;
+        public event MapItemRequest OnMapItemRequest;
+        public event OfferCallingCard OnOfferCallingCard;
+        public event AcceptCallingCard OnAcceptCallingCard;
+        public event DeclineCallingCard OnDeclineCallingCard;
+        public event SoundTrigger OnSoundTrigger;
+        public event StartLure OnStartLure;
+        public event TeleportLureRequest OnTeleportLureRequest;
+        public event NetworkStats OnNetworkStatsUpdate;
+        public event ClassifiedInfoRequest OnClassifiedInfoRequest;
+        public event ClassifiedInfoUpdate OnClassifiedInfoUpdate;
+        public event ClassifiedDelete OnClassifiedDelete;
+        public event ClassifiedDelete OnClassifiedGodDelete;
+        public event EventNotificationAddRequest OnEventNotificationAddRequest;
+        public event EventNotificationRemoveRequest OnEventNotificationRemoveRequest;
+        public event EventGodDelete OnEventGodDelete;
+        public event ParcelDwellRequest OnParcelDwellRequest;
+        public event UserInfoRequest OnUserInfoRequest;
+        public event UpdateUserInfo OnUpdateUserInfo;
+        public event RetrieveInstantMessages OnRetrieveInstantMessages;
+        public event PickDelete OnPickDelete;
+        public event PickGodDelete OnPickGodDelete;
+        public event PickInfoUpdate OnPickInfoUpdate;
+        public event AvatarNotesUpdate OnAvatarNotesUpdate;
+        public event MuteListRequest OnMuteListRequest;
+        public event AvatarInterestUpdate OnAvatarInterestUpdate;
+        public event PlacesQuery OnPlacesQuery;
+        #endregion Events
+        #region Class Members
        // LLClientView Only
        public delegate void BinaryGenericMessage(Object sender, string method, byte[][] args);
@@ -111,17 +314,21 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        protected int m_primFullUpdatesPerPacket = 14;
        protected int m_primTerseUpdateRate = 10;
        protected int m_primFullUpdateRate = 14;
-        protected int m_textureSendLimit   = 20;
-        protected int m_textureDataLimit   = 10;
        protected int m_avatarTerseUpdateRate = 50;
        protected int m_avatarTerseUpdatesPerPacket = 5;
-        protected int m_packetMTU = 1400;
+        /// <summary>Number of texture packets to put on the queue each time the
+        /// OnQueueEmpty event is triggered for the texture category</summary>
+        protected int m_textureSendLimit = 20;
        protected IAssetService m_assetService;
        private IHyperAssetService m_hyperAssets;
+        #endregion Class Members
        #region Properties
+        public LLUDPClient UDPClient { get { return m_udpClient; } }
+        public IPEndPoint RemoteEndPoint { get { return m_udpClient.RemoteEndPoint; } }
        public UUID SecureSessionId { get { return m_secureSessionId; } }
        public IScene Scene { get { return m_scene; } }
        public UUID SessionId { get { return m_sessionId; } }
@@ -202,51 +409,35 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        #region Client Methods
        /// <summary>
-        /// Close down the client view.  This *must* be the last method called, since the last  #
+        /// Shut down the client view
-        /// statement of CloseCleanup() aborts the thread.
        /// </summary>
-        /// <param name="shutdownCircuit"></param>
+        public void Close()
-        public void Close(bool shutdownCircuit)
        {
            m_log.DebugFormat(
-                "[CLIENT]: Close has been called with shutdownCircuit = {0} for {1} attached to scene {2}",
+                "[CLIENT]: Close has been called for {0} attached to scene {1}",
-                shutdownCircuit, Name, m_scene.RegionInfo.RegionName);
+                Name, m_scene.RegionInfo.RegionName);
+            // Send the STOP packet
+            DisableSimulatorPacket disable = (DisableSimulatorPacket)PacketPool.Instance.GetPacket(PacketType.DisableSimulator);
+            OutPacket(disable, ThrottleOutPacketType.Unknown);
+            IsActive = false;
+            // Shutdown the image manager
            if (m_imageManager != null)
                m_imageManager.Close();
+            // Fire the callback for this connection closing
+            if (OnConnectionClosed != null)
+                OnConnectionClosed(this);
+            // Flush all of the packets out of the UDP server for this client
            if (m_udpServer != null)
-                m_udpServer.Flush();
+                m_udpServer.Flush(m_udpClient);
-            // raise an event on the packet server to Shutdown the circuit
-            // Now, if we raise the event then the packet server will call this method itself, so don't try cleanup
-            // here otherwise we'll end up calling it twice.
-            // FIXME: In truth, I might be wrong but this whole business of calling this method twice (with different args) looks
-            // horribly tangly.  Hopefully it should be possible to greatly simplify it.
-            if (shutdownCircuit)
-            {
-                if (OnConnectionClosed != null)
-                    OnConnectionClosed(this);
-            }
-            else
-            {
-                CloseCleanup(shutdownCircuit);
-            }
-        }
-        private void CloseCleanup(bool shutdownCircuit)
+            // Remove ourselves from the scene
-        {
            m_scene.RemoveClient(AgentId);
-            //m_log.InfoFormat("[CLIENTVIEW] Memory pre  GC {0}", System.GC.GetTotalMemory(false));
-            //m_log.InfoFormat("[CLIENTVIEW] Memory post GC {0}", System.GC.GetTotalMemory(true));
-            // Send the STOP packet
-            DisableSimulatorPacket disable = (DisableSimulatorPacket)PacketPool.Instance.GetPacket(PacketType.DisableSimulator);
-            OutPacket(disable, ThrottleOutPacketType.Unknown);
-            Thread.Sleep(2000);
            // Shut down timers. Thread Context of this method is murky.   Lock all timers
            if (m_avatarTerseUpdateTimer.Enabled)
                lock (m_avatarTerseUpdateTimer)
@@ -258,43 +449,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                lock (m_primFullUpdateTimer)
                    m_primFullUpdateTimer.Stop();
-            // This is just to give the client a reasonable chance of
-            // flushing out all it's packets.  There should probably
-            // be a better mechanism here
            // We can't reach into other scenes and close the connection
            // We need to do this over grid communications
            //m_scene.CloseAllAgents(CircuitCode);
-            // If we're not shutting down the circuit, then this is the last time we'll go here.
+            m_avatarTerseUpdateTimer.Dispose();
-            // If we are shutting down the circuit, the UDP Server will come back here with
+            m_primTerseUpdateTimer.Dispose();
-            // ShutDownCircuit = false
+            m_primFullUpdateTimer.Dispose();
-            if (!(shutdownCircuit))
-            {
-                GC.Collect();
-                m_imageManager = null;
-                // Sends a KillPacket object, with which, the
-                // blockingqueue dequeues and sees it's a killpacket
-                // and terminates within the context of the client thread.
-                // This ensures that it's done from within the context
-                // of the client thread regardless of where Close() is called.
-                KillEndDone();
-            }
-            IsActive = false;
-            m_avatarTerseUpdateTimer.Close();
-            m_primTerseUpdateTimer.Close();
-            m_primFullUpdateTimer.Close();
-            //m_udpServer.OnPacketStats -= PopulateStats;
+            // Disable UDP handling for this client
            m_udpClient.Shutdown();
-            // wait for thread stoped
+            //m_log.InfoFormat("[CLIENTVIEW] Memory pre  GC {0}", System.GC.GetTotalMemory(false));
-            // m_clientThread.Join();
+            //GC.Collect();
+            //m_log.InfoFormat("[CLIENTVIEW] Memory post GC {0}", System.GC.GetTotalMemory(true));
-            // delete circuit code
-            //m_networkServer.CloseClient(this);
        }
        public void Kick(string message)
@@ -416,43 +584,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            return result;
        }
-        /*protected void DebugPacket(string direction, Packet packet)
-        {
-            string info;
-            if (m_debugPacketLevel < 255 && packet.Type == PacketType.AgentUpdate)
-                return;
-            if (m_debugPacketLevel < 254 && packet.Type == PacketType.ViewerEffect)
-                return;
-            if (m_debugPacketLevel < 253 && (
-                                     packet.Type == PacketType.CompletePingCheck ||
-                                     packet.Type == PacketType.StartPingCheck
-                                 ))
-                return;
-            if (m_debugPacketLevel < 252 && packet.Type == PacketType.PacketAck)
-                return;
-            if (m_debugPacketLevel > 1)
-            {
-                info = packet.ToString();
-            }
-            else
-            {
-                info = packet.Type.ToString();
-            }
-            Console.WriteLine(m_circuitCode + ":" + direction + ": " + info);
-        }*/
        #endregion Packet Handling
        # region Setup
-        /// <summary>
+        public virtual void Start()
-        /// Starts up the timers to check the client and resend unacked packets
-        /// Adds the client to the OpenSim.Region.Framework.Scenes.Scene
-        /// </summary>
-        protected virtual void InitNewClient()
        {
            m_avatarTerseUpdateTimer = new Timer(m_avatarTerseUpdateRate);
            m_avatarTerseUpdateTimer.Elapsed += new ElapsedEventHandler(ProcessAvatarTerseUpdates);
@@ -471,262 +607,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            RefreshGroupMembership();
        }
-        public virtual void Start()
-        {
-            // This sets up all the timers
-            InitNewClient();
-        }
-        /// <summary>
-        /// Run a user session.  This method lies at the base of the entire client thread.
-        /// </summary>
-        protected void RunUserSession()
-        {
-            try
-            {
-                
-            }
-            catch (Exception e)
-            {
-                if (e is ThreadAbortException)
-                    throw;
-                if (StatsManager.SimExtraStats != null)
-                    StatsManager.SimExtraStats.AddAbnormalClientThreadTermination();
-                // Don't let a failure in an individual client thread crash the whole sim.
-                m_log.ErrorFormat(
-                    "[CLIENT]: Client thread for {0} {1} crashed.  Logging them out.", Name, AgentId);
-                m_log.Error(e.ToString());
-                try
-                {
-                    // Make an attempt to alert the user that their session has crashed
-                    AgentAlertMessagePacket packet
-                        = BuildAgentAlertPacket(
-                            "Unfortunately the session for this client on the server has crashed.\n"
-                                + "Any further actions taken will not be processed.\n"
-                                + "Please relog", true);
-                    m_udpServer.SendPacket(m_agentId, packet, ThrottleOutPacketType.Unknown, false);
-                    // There may be a better way to do this.  Perhaps kick?  Not sure this propogates notifications to
-                    // listeners yet, though.
-                    Logout(this);
-                }
-                catch (Exception e2)
-                {
-                    if (e2 is ThreadAbortException)
-                        throw;
-                    m_log.ErrorFormat("[CLIENT]: Further exception thrown on forced session logout.  {0}", e2);
-                }
-            }
-        }
        # endregion
-        #region Events
-        public event GenericMessage OnGenericMessage;
-        public event BinaryGenericMessage OnBinaryGenericMessage;
-        public event Action<IClientAPI> OnLogout;
-        public event ObjectPermissions OnObjectPermissions;
-        public event Action<IClientAPI> OnConnectionClosed;
-        public event ViewerEffectEventHandler OnViewerEffect;
-        public event ImprovedInstantMessage OnInstantMessage;
-        public event ChatMessage OnChatFromClient;
-        public event TextureRequest OnRequestTexture;
-        public event RezObject OnRezObject;
-        public event DeRezObject OnDeRezObject;
-        public event ModifyTerrain OnModifyTerrain;
-        public event Action<IClientAPI> OnRegionHandShakeReply;
-        public event GenericCall2 OnRequestWearables;
-        public event SetAppearance OnSetAppearance;
-        public event AvatarNowWearing OnAvatarNowWearing;
-        public event RezSingleAttachmentFromInv OnRezSingleAttachmentFromInv;
-        public event RezMultipleAttachmentsFromInv OnRezMultipleAttachmentsFromInv;
-        public event UUIDNameRequest OnDetachAttachmentIntoInv;
-        public event ObjectAttach OnObjectAttach;
-        public event ObjectDeselect OnObjectDetach;
-        public event ObjectDrop OnObjectDrop;
-        public event GenericCall2 OnCompleteMovementToRegion;
-        public event UpdateAgent OnAgentUpdate;
-        public event AgentRequestSit OnAgentRequestSit;
-        public event AgentSit OnAgentSit;
-        public event AvatarPickerRequest OnAvatarPickerRequest;
-        public event StartAnim OnStartAnim;
-        public event StopAnim OnStopAnim;
-        public event Action<IClientAPI> OnRequestAvatarsData;
-        public event LinkObjects OnLinkObjects;
-        public event DelinkObjects OnDelinkObjects;
-        public event GrabObject OnGrabObject;
-        public event DeGrabObject OnDeGrabObject;
-        public event SpinStart OnSpinStart;
-        public event SpinStop OnSpinStop;
-        public event ObjectDuplicate OnObjectDuplicate;
-        public event ObjectDuplicateOnRay OnObjectDuplicateOnRay;
-        public event MoveObject OnGrabUpdate;
-        public event SpinObject OnSpinUpdate;
-        public event AddNewPrim OnAddPrim;
-        public event RequestGodlikePowers OnRequestGodlikePowers;
-        public event GodKickUser OnGodKickUser;
-        public event ObjectExtraParams OnUpdateExtraParams;
-        public event UpdateShape OnUpdatePrimShape;
-        public event ObjectRequest OnObjectRequest;
-        public event ObjectSelect OnObjectSelect;
-        public event ObjectDeselect OnObjectDeselect;
-        public event GenericCall7 OnObjectDescription;
-        public event GenericCall7 OnObjectName;
-        public event GenericCall7 OnObjectClickAction;
-        public event GenericCall7 OnObjectMaterial;
-        public event ObjectIncludeInSearch OnObjectIncludeInSearch;
-        public event RequestObjectPropertiesFamily OnRequestObjectPropertiesFamily;
-        public event UpdatePrimFlags OnUpdatePrimFlags;
-        public event UpdatePrimTexture OnUpdatePrimTexture;
-        public event UpdateVector OnUpdatePrimGroupPosition;
-        public event UpdateVector OnUpdatePrimSinglePosition;
-        public event UpdatePrimRotation OnUpdatePrimGroupRotation;
-        public event UpdatePrimSingleRotation OnUpdatePrimSingleRotation;
-        public event UpdatePrimSingleRotationPosition OnUpdatePrimSingleRotationPosition;
-        public event UpdatePrimGroupRotation OnUpdatePrimGroupMouseRotation;
-        public event UpdateVector OnUpdatePrimScale;
-        public event UpdateVector OnUpdatePrimGroupScale;
-        public event StatusChange OnChildAgentStatus;
-        public event GenericCall2 OnStopMovement;
-        public event Action<UUID> OnRemoveAvatar;
-        public event RequestMapBlocks OnRequestMapBlocks;
-        public event RequestMapName OnMapNameRequest;
-        public event TeleportLocationRequest OnTeleportLocationRequest;
-        public event TeleportLandmarkRequest OnTeleportLandmarkRequest;
-        public event DisconnectUser OnDisconnectUser;
-        public event RequestAvatarProperties OnRequestAvatarProperties;
-        public event SetAlwaysRun OnSetAlwaysRun;
-        public event FetchInventory OnAgentDataUpdateRequest;
-        public event TeleportLocationRequest OnSetStartLocationRequest;
-        public event UpdateAvatarProperties OnUpdateAvatarProperties;
-        public event CreateNewInventoryItem OnCreateNewInventoryItem;
-        public event CreateInventoryFolder OnCreateNewInventoryFolder;
-        public event UpdateInventoryFolder OnUpdateInventoryFolder;
-        public event MoveInventoryFolder OnMoveInventoryFolder;
-        public event FetchInventoryDescendents OnFetchInventoryDescendents;
-        public event PurgeInventoryDescendents OnPurgeInventoryDescendents;
-        public event FetchInventory OnFetchInventory;
-        public event RequestTaskInventory OnRequestTaskInventory;
-        public event UpdateInventoryItem OnUpdateInventoryItem;
-        public event CopyInventoryItem OnCopyInventoryItem;
-        public event MoveInventoryItem OnMoveInventoryItem;
-        public event RemoveInventoryItem OnRemoveInventoryItem;
-        public event RemoveInventoryFolder OnRemoveInventoryFolder;
-        public event UDPAssetUploadRequest OnAssetUploadRequest;
-        public event XferReceive OnXferReceive;
-        public event RequestXfer OnRequestXfer;
-        public event ConfirmXfer OnConfirmXfer;
-        public event AbortXfer OnAbortXfer;
-        public event RequestTerrain OnRequestTerrain;
-        public event RezScript OnRezScript;
-        public event UpdateTaskInventory OnUpdateTaskInventory;
-        public event MoveTaskInventory OnMoveTaskItem;
-        public event RemoveTaskInventory OnRemoveTaskItem;
-        public event RequestAsset OnRequestAsset;
-        public event UUIDNameRequest OnNameFromUUIDRequest;
-        public event ParcelAccessListRequest OnParcelAccessListRequest;
-        public event ParcelAccessListUpdateRequest OnParcelAccessListUpdateRequest;
-        public event ParcelPropertiesRequest OnParcelPropertiesRequest;
-        public event ParcelDivideRequest OnParcelDivideRequest;
-        public event ParcelJoinRequest OnParcelJoinRequest;
-        public event ParcelPropertiesUpdateRequest OnParcelPropertiesUpdateRequest;
-        public event ParcelSelectObjects OnParcelSelectObjects;
-        public event ParcelObjectOwnerRequest OnParcelObjectOwnerRequest;
-        public event ParcelAbandonRequest OnParcelAbandonRequest;
-        public event ParcelGodForceOwner OnParcelGodForceOwner;
-        public event ParcelReclaim OnParcelReclaim;
-        public event ParcelReturnObjectsRequest OnParcelReturnObjectsRequest;
-        public event ParcelDeedToGroup OnParcelDeedToGroup;
-        public event RegionInfoRequest OnRegionInfoRequest;
-        public event EstateCovenantRequest OnEstateCovenantRequest;
-        public event FriendActionDelegate OnApproveFriendRequest;
-        public event FriendActionDelegate OnDenyFriendRequest;
-        public event FriendshipTermination OnTerminateFriendship;
-        public event MoneyTransferRequest OnMoneyTransferRequest;
-        public event EconomyDataRequest OnEconomyDataRequest;
-        public event MoneyBalanceRequest OnMoneyBalanceRequest;
-        public event ParcelBuy OnParcelBuy;
-        public event UUIDNameRequest OnTeleportHomeRequest;
-        public event UUIDNameRequest OnUUIDGroupNameRequest;
-        public event ScriptAnswer OnScriptAnswer;
-        public event RequestPayPrice OnRequestPayPrice;
-        public event ObjectSaleInfo OnObjectSaleInfo;
-        public event ObjectBuy OnObjectBuy;
-        public event BuyObjectInventory OnBuyObjectInventory;
-        public event AgentSit OnUndo;
-        public event ForceReleaseControls OnForceReleaseControls;
-        public event GodLandStatRequest OnLandStatRequest;
-        public event RequestObjectPropertiesFamily OnObjectGroupRequest;
-        public event DetailedEstateDataRequest OnDetailedEstateDataRequest;
-        public event SetEstateFlagsRequest OnSetEstateFlagsRequest;
-        public event SetEstateTerrainBaseTexture OnSetEstateTerrainBaseTexture;
-        public event SetEstateTerrainDetailTexture OnSetEstateTerrainDetailTexture;
-        public event SetEstateTerrainTextureHeights OnSetEstateTerrainTextureHeights;
-        public event CommitEstateTerrainTextureRequest OnCommitEstateTerrainTextureRequest;
-        public event SetRegionTerrainSettings OnSetRegionTerrainSettings;
-        public event BakeTerrain OnBakeTerrain;
-        public event RequestTerrain OnUploadTerrain;
-        public event EstateChangeInfo OnEstateChangeInfo;
-        public event EstateRestartSimRequest OnEstateRestartSimRequest;
-        public event EstateChangeCovenantRequest OnEstateChangeCovenantRequest;
-        public event UpdateEstateAccessDeltaRequest OnUpdateEstateAccessDeltaRequest;
-        public event SimulatorBlueBoxMessageRequest OnSimulatorBlueBoxMessageRequest;
-        public event EstateBlueBoxMessageRequest OnEstateBlueBoxMessageRequest;
-        public event EstateDebugRegionRequest OnEstateDebugRegionRequest;
-        public event EstateTeleportOneUserHomeRequest OnEstateTeleportOneUserHomeRequest;
-        public event EstateTeleportAllUsersHomeRequest OnEstateTeleportAllUsersHomeRequest;
-        public event RegionHandleRequest OnRegionHandleRequest;
-        public event ParcelInfoRequest OnParcelInfoRequest;
-        public event ScriptReset OnScriptReset;
-        public event GetScriptRunning OnGetScriptRunning;
-        public event SetScriptRunning OnSetScriptRunning;
-        public event UpdateVector OnAutoPilotGo;
-        public event TerrainUnacked OnUnackedTerrain;
-        public event ActivateGesture OnActivateGesture;
-        public event DeactivateGesture OnDeactivateGesture;
-        public event ObjectOwner OnObjectOwner;
-        public event DirPlacesQuery OnDirPlacesQuery;
-        public event DirFindQuery OnDirFindQuery;
-        public event DirLandQuery OnDirLandQuery;
-        public event DirPopularQuery OnDirPopularQuery;
-        public event DirClassifiedQuery OnDirClassifiedQuery;
-        public event EventInfoRequest OnEventInfoRequest;
-        public event ParcelSetOtherCleanTime OnParcelSetOtherCleanTime;
-        public event MapItemRequest OnMapItemRequest;
-        public event OfferCallingCard OnOfferCallingCard;
-        public event AcceptCallingCard OnAcceptCallingCard;
-        public event DeclineCallingCard OnDeclineCallingCard;
-        public event SoundTrigger OnSoundTrigger;
-        public event StartLure OnStartLure;
-        public event TeleportLureRequest OnTeleportLureRequest;
-        public event NetworkStats OnNetworkStatsUpdate;
-        public event ClassifiedInfoRequest OnClassifiedInfoRequest;
-        public event ClassifiedInfoUpdate OnClassifiedInfoUpdate;
-        public event ClassifiedDelete OnClassifiedDelete;
-        public event ClassifiedDelete OnClassifiedGodDelete;
-        public event EventNotificationAddRequest OnEventNotificationAddRequest;
-        public event EventNotificationRemoveRequest OnEventNotificationRemoveRequest;
-        public event EventGodDelete OnEventGodDelete;
-        public event ParcelDwellRequest OnParcelDwellRequest;
-        public event UserInfoRequest OnUserInfoRequest;
-        public event UpdateUserInfo OnUpdateUserInfo;
-        public event RetrieveInstantMessages OnRetrieveInstantMessages;
-        public event PickDelete OnPickDelete;
-        public event PickGodDelete OnPickGodDelete;
-        public event PickInfoUpdate OnPickInfoUpdate;
-        public event AvatarNotesUpdate OnAvatarNotesUpdate;
-        public event MuteListRequest OnMuteListRequest;
-        public event AvatarInterestUpdate OnAvatarInterestUpdate;
-        public event PlacesQuery OnPlacesQuery;
-        #endregion Events
        public void ActivateGesture(UUID assetId, UUID gestureId)
        {
        }
@@ -1346,7 +1228,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            kill.ObjectData[0].ID = localID;
            kill.Header.Reliable = true;
            kill.Header.Zerocoded = true;
-            OutPacket(kill, ThrottleOutPacketType.Task);
+            OutPacket(kill, ThrottleOutPacketType.State);
        }
        /// <summary>
@@ -1940,7 +1822,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            sendXfer.XferID.ID = xferID;
            sendXfer.XferID.Packet = packet;
            sendXfer.DataPacket.Data = data;
-            OutPacket(sendXfer, ThrottleOutPacketType.Task);
+            OutPacket(sendXfer, ThrottleOutPacketType.Asset);
        }
        public void SendEconomyData(float EnergyEfficiency, int ObjectCapacity, int ObjectCount, int PriceEnergyUnit,
@@ -2222,7 +2104,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            packet.AgentData.SessionID = SessionId;
            packet.Header.Reliable = false;
            packet.Header.Zerocoded = true;
-            OutPacket(packet, ThrottleOutPacketType.Task);
+            OutPacket(packet, ThrottleOutPacketType.State);
        }
        public void SendAvatarProperties(UUID avatarID, string aboutText, string bornOn, Byte[] charterMember,
@@ -3245,7 +3127,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            avp.Sender.IsTrial = false;
            avp.Sender.ID = agentID;
-            OutPacket(avp, ThrottleOutPacketType.Task);
+            OutPacket(avp, ThrottleOutPacketType.State);
        }
        public void SendAnimations(UUID[] animations, int[] seqs, UUID sourceAgentId, UUID[] objectIDs)
@@ -3370,7 +3252,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                    int length = 0;
                    m_avatarTerseUpdates[count].ToBytes(blockbuffer, ref length);
                    length = Helpers.ZeroEncode(blockbuffer, length, zerobuffer);
-                    if (size + length > m_packetMTU)
+                    if (size + length > Packet.MTU)
                        break;
                    size += length;
                }
@@ -3385,6 +3267,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                terse.Header.Reliable = false;
                terse.Header.Zerocoded = true;
+                // FIXME: Move this to ThrottleOutPacketType.State when the real prioritization code is committed
                OutPacket(terse, ThrottleOutPacketType.Task);
                if (m_avatarTerseUpdates.Count == 0)
@@ -3575,7 +3458,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        void ProcessTextureRequests()
        {
            if (m_imageManager != null)
-                m_imageManager.ProcessImageQueue(m_textureSendLimit, m_textureDataLimit);
+                m_imageManager.ProcessImageQueue(m_textureSendLimit);
        }
        void ProcessPrimFullUpdates(object sender, ElapsedEventArgs e)
@@ -3614,7 +3497,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                    int length = 0;
                    m_primFullUpdates[count].ToBytes(blockbuffer, ref length);
                    length = Helpers.ZeroEncode(blockbuffer, length, zerobuffer);
-                    if (size + length > m_packetMTU)
+                    if (size + length > Packet.MTU)
                        break;
                    size += length;
                }
@@ -3629,7 +3512,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                }
                outPacket.Header.Zerocoded = true;
-                OutPacket(outPacket, ThrottleOutPacketType.Task);
+                OutPacket(outPacket, ThrottleOutPacketType.State);
                if (m_primFullUpdates.Count == 0 && m_primFullUpdateTimer.Enabled)
                    lock (m_primFullUpdateTimer)
@@ -3702,7 +3585,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                    int length = 0;
                    m_primTerseUpdates[count].ToBytes(blockbuffer, ref length);
                    length = Helpers.ZeroEncode(blockbuffer, length, zerobuffer);
-                    if (size + length > m_packetMTU)
+                    if (size + length > Packet.MTU)
                        break;
                    size += length;
                }
@@ -3719,7 +3602,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                outPacket.Header.Reliable = false;
                outPacket.Header.Zerocoded = true;
-                OutPacket(outPacket, ThrottleOutPacketType.Task);
+                OutPacket(outPacket, ThrottleOutPacketType.State);
                if (m_primTerseUpdates.Count == 0)
                    lock (m_primTerseUpdateTimer)
@@ -4805,7 +4688,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        public bool HandleObjectGroupRequest(IClientAPI sender, Packet Pack)
        {
            ObjectGroupPacket ogpack = (ObjectGroupPacket)Pack;
            if (ogpack.AgentData.SessionID != SessionId) return false;
@@ -10252,7 +10134,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        public void KillEndDone()
        {
-            m_udpClient.Shutdown();
        }
        #region IClientCore
@@ -10295,15 +10176,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        {
            Kick(reason);
            Thread.Sleep(1000);
-            Close(true);
+            Close();
        }
        public void Disconnect()
        {
-            Close(true);
+            Close();
        }
        #endregion
        public void RefreshGroupMembership()
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLImageManager.cs b/OpenSim/Region/ClientStack/LindenUDP/LLImageManager.cs
index 56d34e6..d25bf95 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLImageManager.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLImageManager.cs
@@ -167,47 +167,48 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            }
        }
-        public bool ProcessImageQueue(int count, int maxpack)
+        public bool ProcessImageQueue(int packetsToSend)
        {
-            J2KImage imagereq;
+            m_lastloopprocessed = DateTime.Now.Ticks;
-            int numCollected = 0;
+            int packetsSent = 0;
-            //lock (m_syncRoot)
+            while (packetsSent < packetsToSend)
-            //{
+            {
-                m_lastloopprocessed = DateTime.Now.Ticks;
+                J2KImage image = GetHighestPriorityImage();
-                // This can happen during Close()
+                // If null was returned, the texture priority queue is currently empty
-                if (m_client == null)
+                if (image == null)
                    return false;
-                
-                while ((imagereq = GetHighestPriorityImage()) != null)
-                {
-                    if (imagereq.IsDecoded == true)
-                    {
-                        ++numCollected;
-                        if (imagereq.SendPackets(m_client, maxpack))
+                if (image.IsDecoded)
-                        {
+                {
-                            // Send complete. Destroy any knowledge of this transfer
+                    int sent;
-                            RemoveImageFromQueue(imagereq);
+                    bool imageDone = image.SendPackets(m_client, packetsToSend - packetsSent, out sent);
-                        }
+                    packetsSent += sent;
-                    }
-                    if (numCollected == count)
+                    // If the send is complete, destroy any knowledge of this transfer
-                        break;
+                    if (imageDone)
+                        RemoveImageFromQueue(image);
                }
-            //}
+                else
+                {
+                    // TODO: This is a limitation of how LLImageManager is currently
+                    // written. Undecoded textures should not be going into the priority
+                    // queue, because a high priority undecoded texture will clog up the
+                    // pipeline for a client
+                    return true;
+                }
+            }
            return m_priorityQueue.Count > 0;
        }
-        //Faux destructor
+        /// <summary>
+        /// Faux destructor
+        /// </summary>
        public void Close()
        {
            m_shuttingdown = true;
-            m_j2kDecodeModule = null;
-            m_assetCache = null;
-            m_client = null;
        }
        #region Priority Queue Helpers
@@ -218,13 +219,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            lock (m_syncRoot)
            {
                if (m_priorityQueue.Count > 0)
                {
-                    try
+                    try { image = m_priorityQueue.FindMax(); }
-                    {
-                        image = m_priorityQueue.FindMax();
-                    }
                    catch (Exception) { }
                }
            }
@@ -236,20 +233,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            image.PriorityQueueHandle = null;
            lock (m_syncRoot)
-                try
+                try { m_priorityQueue.Add(ref image.PriorityQueueHandle, image); }
-                {
-                    m_priorityQueue.Add(ref image.PriorityQueueHandle, image);
-                }
                catch (Exception) { }
        }
        void RemoveImageFromQueue(J2KImage image)
        {
            lock (m_syncRoot)
-                try
+                try { m_priorityQueue.Delete(image.PriorityQueueHandle); }
-                {
-                    m_priorityQueue.Delete(image.PriorityQueueHandle);
-                }
                catch (Exception) { }
        }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
index 871e8e8..4eee6b6 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
@@ -28,8 +28,10 @@
 using System;
 using System.Collections.Generic;
 using System.Net;
+using log4net;
 using OpenSim.Framework;
 using OpenMetaverse;
+using OpenMetaverse.Packets;
 namespace OpenSim.Region.ClientStack.LindenUDP
 {
@@ -59,9 +61,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
    /// </summary>
    public sealed class LLUDPClient
    {
+        // TODO: Make this a config setting
+        /// <summary>Percentage of the task throttle category that is allocated to avatar and prim
+        /// state updates</summary>
+        const float STATE_TASK_PERCENTAGE = 0.8f;
+        private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        /// <summary>The number of packet categories to throttle on. If a throttle category is added
        /// or removed, this number must also change</summary>
-        const int THROTTLE_CATEGORY_COUNT = 7;
+        const int THROTTLE_CATEGORY_COUNT = 8;
        /// <summary>Fired when updated networking stats are produced for this client</summary>
        public event PacketStats OnPacketStats;
@@ -80,10 +89,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        /// <summary>Packets we have sent that need to be ACKed by the client</summary>
        public readonly UnackedPacketCollection NeedAcks = new UnackedPacketCollection();
        /// <summary>ACKs that are queued up, waiting to be sent to the client</summary>
-        public readonly LocklessQueue<uint> PendingAcks = new LocklessQueue<uint>();
+        public readonly OpenSim.Framework.LocklessQueue<uint> PendingAcks = new OpenSim.Framework.LocklessQueue<uint>();
-        /// <summary>Reference to the IClientAPI for this client</summary>
-        public LLClientView ClientAPI;
        /// <summary>Current packet sequence number</summary>
        public int CurrentSequence;
        /// <summary>Current ping sequence number</summary>
@@ -123,21 +130,21 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        private int m_packetsSentReported;
        /// <summary>Throttle bucket for this agent's connection</summary>
-        private readonly TokenBucket throttle;
+        private readonly TokenBucket m_throttle;
        /// <summary>Throttle buckets for each packet category</summary>
-        private readonly TokenBucket[] throttleCategories;
+        private readonly TokenBucket[] m_throttleCategories;
        /// <summary>Throttle rate defaults and limits</summary>
-        private readonly ThrottleRates defaultThrottleRates;
+        private readonly ThrottleRates m_defaultThrottleRates;
        /// <summary>Outgoing queues for throttled packets</summary>
-        private readonly LocklessQueue<OutgoingPacket>[] packetOutboxes = new LocklessQueue<OutgoingPacket>[THROTTLE_CATEGORY_COUNT];
+        private readonly OpenSim.Framework.LocklessQueue<OutgoingPacket>[] m_packetOutboxes = new OpenSim.Framework.LocklessQueue<OutgoingPacket>[THROTTLE_CATEGORY_COUNT];
        /// <summary>A container that can hold one packet for each outbox, used to store
        /// dequeued packets that are being held for throttling</summary>
-        private readonly OutgoingPacket[] nextPackets = new OutgoingPacket[THROTTLE_CATEGORY_COUNT];
+        private readonly OutgoingPacket[] m_nextPackets = new OutgoingPacket[THROTTLE_CATEGORY_COUNT];
-        /// <summary>An optimization to store the length of dequeued packets being held
+        /// <summary>Flags to prevent queue empty callbacks from stacking up on
-        /// for throttling. This avoids expensive calls to Packet.Length</summary>
+        /// top of each other</summary>
-        private readonly int[] nextPacketLengths = new int[THROTTLE_CATEGORY_COUNT];
+        private readonly bool[] m_onQueueEmptyRunning = new bool[THROTTLE_CATEGORY_COUNT];
        /// <summary>A reference to the LLUDPServer that is managing this client</summary>
-        private readonly LLUDPServer udpServer;
+        private readonly LLUDPServer m_udpServer;
        /// <summary>
        /// Default constructor
@@ -151,24 +158,21 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        /// <param name="remoteEndPoint">Remote endpoint for this connection</param>
        public LLUDPClient(LLUDPServer server, ThrottleRates rates, TokenBucket parentThrottle, uint circuitCode, UUID agentID, IPEndPoint remoteEndPoint)
        {
-            udpServer = server;
            AgentID = agentID;
            RemoteEndPoint = remoteEndPoint;
            CircuitCode = circuitCode;
-            defaultThrottleRates = rates;
+            m_udpServer = server;
+            m_defaultThrottleRates = rates;
+            m_throttle = new TokenBucket(parentThrottle, rates.TotalLimit, rates.Total);
+            m_throttleCategories = new TokenBucket[THROTTLE_CATEGORY_COUNT];
            for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
-                packetOutboxes[i] = new LocklessQueue<OutgoingPacket>();
+            {
+                ThrottleOutPacketType type = (ThrottleOutPacketType)i;
-            throttle = new TokenBucket(parentThrottle, 0, 0);
-            throttleCategories = new TokenBucket[THROTTLE_CATEGORY_COUNT];
+                m_packetOutboxes[i] = new OpenSim.Framework.LocklessQueue<OutgoingPacket>();
-            throttleCategories[(int)ThrottleOutPacketType.Resend] = new TokenBucket(throttle, rates.ResendLimit, rates.Resend);
+                m_throttleCategories[i] = new TokenBucket(m_throttle, rates.GetLimit(type), rates.GetRate(type));
-            throttleCategories[(int)ThrottleOutPacketType.Land] = new TokenBucket(throttle, rates.LandLimit, rates.Land);
+            }
-            throttleCategories[(int)ThrottleOutPacketType.Wind] = new TokenBucket(throttle, rates.WindLimit, rates.Wind);
-            throttleCategories[(int)ThrottleOutPacketType.Cloud] = new TokenBucket(throttle, rates.CloudLimit, rates.Cloud);
-            throttleCategories[(int)ThrottleOutPacketType.Task] = new TokenBucket(throttle, rates.TaskLimit, rates.Task);
-            throttleCategories[(int)ThrottleOutPacketType.Texture] = new TokenBucket(throttle, rates.TextureLimit, rates.Texture);
-            throttleCategories[(int)ThrottleOutPacketType.Asset] = new TokenBucket(throttle, rates.AssetLimit, rates.Asset);
            // Set the granularity variable used for retransmission calculations to
            // the measured resolution of Environment.TickCount
@@ -176,6 +180,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            // Default the retransmission timeout to three seconds
            RTO = 3000;
+            // Initialize this to a sane value to prevent early disconnects
+            TickLastPacketReceived = Environment.TickCount;
        }
        /// <summary>
@@ -183,8 +190,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        /// </summary>
        public void Shutdown()
        {
-            // TODO: Do we need to invalidate the circuit?
            IsConnected = false;
+            NeedAcks.Clear();
+            for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
+            {
+                m_packetOutboxes[i].Clear();
+                m_nextPackets[i] = null;
+            }
+            OnPacketStats = null;
+            OnQueueEmpty = null;
        }
        /// <summary>
@@ -200,13 +214,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            info.pendingAcks = new Dictionary<uint, uint>();
            info.needAck = new Dictionary<uint, byte[]>();
-            info.resendThrottle = throttleCategories[(int)ThrottleOutPacketType.Resend].DripRate;
+            info.resendThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Resend].DripRate;
-            info.landThrottle = throttleCategories[(int)ThrottleOutPacketType.Land].DripRate;
+            info.landThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Land].DripRate;
-            info.windThrottle = throttleCategories[(int)ThrottleOutPacketType.Wind].DripRate;
+            info.windThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Wind].DripRate;
-            info.cloudThrottle = throttleCategories[(int)ThrottleOutPacketType.Cloud].DripRate;
+            info.cloudThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Cloud].DripRate;
-            info.taskThrottle = throttleCategories[(int)ThrottleOutPacketType.Task].DripRate;
+            info.taskThrottle = m_throttleCategories[(int)ThrottleOutPacketType.State].DripRate + m_throttleCategories[(int)ThrottleOutPacketType.Task].DripRate;
-            info.assetThrottle = throttleCategories[(int)ThrottleOutPacketType.Asset].DripRate;
+            info.assetThrottle = m_throttleCategories[(int)ThrottleOutPacketType.Asset].DripRate;
-            info.textureThrottle = throttleCategories[(int)ThrottleOutPacketType.Texture].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;
@@ -267,6 +281,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                adjData = throttleData;
            }
+            // 0.125f converts from bits to bytes
            int resend = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
            int land = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
            int wind = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
@@ -274,22 +289,40 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            int task = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
            int texture = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); pos += 4;
            int asset = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f);
+            // State is a subcategory of task that we allocate a percentage to
+            int state = (int)((float)task * STATE_TASK_PERCENTAGE);
+            task -= state;
+            int ceiling = Int32.MaxValue;
+            if (m_defaultThrottleRates.Total != 0)
+            {
+                ceiling = m_defaultThrottleRates.Total;
+                if (ceiling < Packet.MTU) ceiling = Packet.MTU;
+            }
-            resend = (resend <= defaultThrottleRates.ResendLimit) ? resend : defaultThrottleRates.ResendLimit;
+            resend = Utils.Clamp(resend, Packet.MTU, ceiling);
-            land = (land <= defaultThrottleRates.LandLimit) ? land : defaultThrottleRates.LandLimit;
+            land = Utils.Clamp(land, Packet.MTU, ceiling);
-            wind = (wind <= defaultThrottleRates.WindLimit) ? wind : defaultThrottleRates.WindLimit;
+            wind = Utils.Clamp(wind, Packet.MTU, ceiling);
-            cloud = (cloud <= defaultThrottleRates.CloudLimit) ? cloud : defaultThrottleRates.CloudLimit;
+            cloud = Utils.Clamp(cloud, Packet.MTU, ceiling);
-            task = (task <= defaultThrottleRates.TaskLimit) ? task : defaultThrottleRates.TaskLimit;
+            task = Utils.Clamp(task, Packet.MTU, ceiling);
-            texture = (texture <= defaultThrottleRates.TextureLimit) ? texture : defaultThrottleRates.TextureLimit;
+            texture = Utils.Clamp(texture, Packet.MTU, ceiling);
-            asset = (asset <= defaultThrottleRates.AssetLimit) ? asset : defaultThrottleRates.AssetLimit;
+            asset = Utils.Clamp(asset, Packet.MTU, ceiling);
+            state = Utils.Clamp(state, Packet.MTU, ceiling);
-            SetThrottle(ThrottleOutPacketType.Resend, resend);
-            SetThrottle(ThrottleOutPacketType.Land, land);
+            int total = resend + land + wind + cloud + task + texture + asset + state;
-            SetThrottle(ThrottleOutPacketType.Wind, wind);
+            int taskTotal = task + state;
-            SetThrottle(ThrottleOutPacketType.Cloud, cloud);
-            SetThrottle(ThrottleOutPacketType.Task, task);
+            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}",
-            SetThrottle(ThrottleOutPacketType.Texture, texture);
+                AgentID, resend, land, wind, cloud, task, texture, asset, state, total);
-            SetThrottle(ThrottleOutPacketType.Asset, asset);
+            SetThrottle(ThrottleOutPacketType.Resend, resend, resend);
+            SetThrottle(ThrottleOutPacketType.Land, land, land);
+            SetThrottle(ThrottleOutPacketType.Wind, wind, wind);
+            SetThrottle(ThrottleOutPacketType.Cloud, cloud, cloud);
+            SetThrottle(ThrottleOutPacketType.Task, task, taskTotal);
+            SetThrottle(ThrottleOutPacketType.Texture, texture, texture);
+            SetThrottle(ThrottleOutPacketType.Asset, asset, asset);
+            SetThrottle(ThrottleOutPacketType.State, state, taskTotal);
        }
        public byte[] GetThrottlesPacked()
@@ -297,25 +330,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            byte[] data = new byte[7 * 4];
            int i = 0;
-            Buffer.BlockCopy(Utils.FloatToBytes((float)throttleCategories[(int)ThrottleOutPacketType.Resend].DripRate), 0, data, i, 4); i += 4;
+            Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Resend].DripRate), 0, data, i, 4); i += 4;
-            Buffer.BlockCopy(Utils.FloatToBytes((float)throttleCategories[(int)ThrottleOutPacketType.Land].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)throttleCategories[(int)ThrottleOutPacketType.Wind].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)throttleCategories[(int)ThrottleOutPacketType.Cloud].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)throttleCategories[(int)ThrottleOutPacketType.Task].DripRate), 0, data, i, 4); i += 4;
+            Buffer.BlockCopy(Utils.FloatToBytes((float)(m_throttleCategories[(int)ThrottleOutPacketType.Task].DripRate) +
-            Buffer.BlockCopy(Utils.FloatToBytes((float)throttleCategories[(int)ThrottleOutPacketType.Texture].DripRate), 0, data, i, 4); i += 4;
+                                                        m_throttleCategories[(int)ThrottleOutPacketType.State].DripRate), 0, data, i, 4); i += 4;
-            Buffer.BlockCopy(Utils.FloatToBytes((float)throttleCategories[(int)ThrottleOutPacketType.Asset].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;
            return data;
        }
-        public void SetThrottle(ThrottleOutPacketType category, int rate)
+        public void SetThrottle(ThrottleOutPacketType category, int rate, int maxBurst)
        {
            int i = (int)category;
-            if (i >= 0 && i < throttleCategories.Length)
+            if (i >= 0 && i < m_throttleCategories.Length)
            {
-                TokenBucket bucket = throttleCategories[(int)category];
+                TokenBucket bucket = m_throttleCategories[(int)category];
-                bucket.MaxBurst = rate;
                bucket.DripRate = rate;
+                bucket.MaxBurst = maxBurst;
            }
        }
@@ -323,12 +357,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        {
            int category = (int)packet.Category;
-            if (category >= 0 && category < packetOutboxes.Length)
+            if (category >= 0 && category < m_packetOutboxes.Length)
            {
-                LocklessQueue<OutgoingPacket> queue = packetOutboxes[category];
+                OpenSim.Framework.LocklessQueue<OutgoingPacket> queue = m_packetOutboxes[category];
-                TokenBucket bucket = throttleCategories[category];
+                TokenBucket bucket = m_throttleCategories[category];
-                if (throttleCategories[category].RemoveTokens(packet.Buffer.DataLength))
+                if (m_throttleCategories[category].RemoveTokens(packet.Buffer.DataLength))
                {
                    // Enough tokens were removed from the bucket, the packet will not be queued
                    return false;
@@ -357,24 +391,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        public bool DequeueOutgoing()
        {
            OutgoingPacket packet;
-            LocklessQueue<OutgoingPacket> queue;
+            OpenSim.Framework.LocklessQueue<OutgoingPacket> queue;
            TokenBucket bucket;
            bool packetSent = false;
            for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
            {
-                bucket = throttleCategories[i];
+                bucket = m_throttleCategories[i];
-                if (nextPackets[i] != null)
+                if (m_nextPackets[i] != null)
                {
                    // This bucket was empty the last time we tried to send a packet,
                    // leaving a dequeued packet still waiting to be sent out. Try to
                    // send it again
-                    if (bucket.RemoveTokens(nextPacketLengths[i]))
+                    OutgoingPacket nextPacket = m_nextPackets[i];
+                    if (bucket.RemoveTokens(nextPacket.Buffer.DataLength))
                    {
                        // Send the packet
-                        udpServer.SendPacketFinal(nextPackets[i]);
+                        m_udpServer.SendPacketFinal(nextPacket);
-                        nextPackets[i] = null;
+                        m_nextPackets[i] = null;
                        packetSent = true;
                    }
                }
@@ -382,7 +417,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                {
                    // No dequeued packet waiting to be sent, try to pull one off
                    // this queue
-                    queue = packetOutboxes[i];
+                    queue = m_packetOutboxes[i];
                    if (queue.Dequeue(out packet))
                    {
                        // A packet was pulled off the queue. See if we have
@@ -390,23 +425,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                        if (bucket.RemoveTokens(packet.Buffer.DataLength))
                        {
                            // Send the packet
-                            udpServer.SendPacketFinal(packet);
+                            m_udpServer.SendPacketFinal(packet);
                            packetSent = true;
                        }
                        else
                        {
-                            // Save the dequeued packet and the length calculation for
+                            // Save the dequeued packet for the next iteration
-                            // the next iteration
+                            m_nextPackets[i] = packet;
-                            nextPackets[i] = packet;
-                            nextPacketLengths[i] = packet.Buffer.DataLength;
                        }
+                        // 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)
+                            BeginFireQueueEmpty(i);
                    }
                    else
                    {
                        // No packets in this queue. Fire the queue empty callback
-                        QueueEmpty callback = OnQueueEmpty;
+                        // if it has not been called recently
-                        if (callback != null)
+                        BeginFireQueueEmpty(i);
-                            callback((ThrottleOutPacketType)i);
                    }
                }
            }
@@ -414,6 +452,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            return packetSent;
        }
+        /// <summary>
+        /// Called when an ACK packet is received and a round-trip time for a
+        /// packet is calculated. This is used to calculate the smoothed
+        /// round-trip time, round trip time variance, and finally the
+        /// retransmission timeout
+        /// </summary>
+        /// <param name="r">Round-trip time of a single packet and its
+        /// acknowledgement</param>
        public void UpdateRoundTrip(float r)
        {
            const float ALPHA = 0.125f;
@@ -435,8 +481,44 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            // Always round retransmission timeout up to two seconds
            RTO = Math.Max(2000, (int)(SRTT + Math.Max(G, K * RTTVAR)));
-            //Logger.Debug("Setting agent " + this.Agent.FullName + "'s RTO to " + RTO + "ms with an RTTVAR of " +
+            //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");
        }
+        /// <summary>
+        /// 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>
+        private void BeginFireQueueEmpty(int throttleIndex)
+        {
+            if (!m_onQueueEmptyRunning[throttleIndex])
+                Util.FireAndForget(FireQueueEmpty, throttleIndex);
+        }
+        /// <summary>
+        /// Checks to see if this queue empty callback is already running,
+        /// then firing the event
+        /// </summary>
+        /// <param name="o">Throttle category to fire the callback for, stored
+        /// as an object to match the WaitCallback delegate signature</param>
+        private void FireQueueEmpty(object o)
+        {
+            int i = (int)o;
+            ThrottleOutPacketType type = (ThrottleOutPacketType)i;
+            QueueEmpty callback = OnQueueEmpty;
+            if (callback != null)
+            {
+                if (!m_onQueueEmptyRunning[i])
+                {
+                    m_onQueueEmptyRunning[i] = true;
+                    try { callback(type); }
+                    catch (Exception e) { m_log.Error("[LLUDPCLIENT]: OnQueueEmpty(" + type + ") threw an exception: " + e.Message, e); }
+                    m_onQueueEmptyRunning[i] = false;
+                }
+            }
+        }
    }
 }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClientCollection.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClientCollection.cs
deleted file mode 100644
index dbb9861..0000000
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClientCollection.cs
+++ /dev/null
@@ -1,282 +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 OpenSim.Framework;
-using OpenMetaverse;
-using ReaderWriterLockImpl = OpenMetaverse.ReaderWriterLockSlim;
-namespace OpenSim.Region.ClientStack.LindenUDP
-{
-    public sealed class UDPClientCollection
-    {
-        Dictionary<UUID, LLUDPClient> Dictionary1;
-        Dictionary<IPEndPoint, LLUDPClient> Dictionary2;
-        LLUDPClient[] Array;
-        ReaderWriterLockImpl rwLock = new ReaderWriterLockImpl();
-        object m_sync = new object();
-        public UDPClientCollection()
-        {
-            Dictionary1 = new Dictionary<UUID, LLUDPClient>();
-            Dictionary2 = new Dictionary<IPEndPoint, LLUDPClient>();
-            Array = new LLUDPClient[0];
-        }
-        public UDPClientCollection(int capacity)
-        {
-            Dictionary1 = new Dictionary<UUID, LLUDPClient>(capacity);
-            Dictionary2 = new Dictionary<IPEndPoint, LLUDPClient>(capacity);
-            Array = new LLUDPClient[0];
-        }
-        public void Add(UUID key1, IPEndPoint key2, LLUDPClient value)
-        {
-            //rwLock.EnterWriteLock();
-            //try
-            //{
-            //    if (Dictionary1.ContainsKey(key1))
-            //    {
-            //        if (!Dictionary2.ContainsKey(key2))
-            //            throw new ArgumentException("key1 exists in the dictionary but not key2");
-            //    }
-            //    else if (Dictionary2.ContainsKey(key2))
-            //    {
-            //        if (!Dictionary1.ContainsKey(key1))
-            //            throw new ArgumentException("key2 exists in the dictionary but not key1");
-            //    }
-            //    Dictionary1[key1] = value;
-            //    Dictionary2[key2] = value;
-            //    LLUDPClient[] oldArray = Array;
-            //    int oldLength = oldArray.Length;
-            //    LLUDPClient[] newArray = new LLUDPClient[oldLength + 1];
-            //    for (int i = 0; i < oldLength; i++)
-            //        newArray[i] = oldArray[i];
-            //    newArray[oldLength] = value;
-            //    Array = newArray;
-            //}
-            //finally { rwLock.ExitWriteLock(); }
-            lock (m_sync)
-            {
-                if (Dictionary1.ContainsKey(key1))
-                {
-                    if (!Dictionary2.ContainsKey(key2))
-                        throw new ArgumentException("key1 exists in the dictionary but not key2");
-                }
-                else if (Dictionary2.ContainsKey(key2))
-                {
-                    if (!Dictionary1.ContainsKey(key1))
-                        throw new ArgumentException("key2 exists in the dictionary but not key1");
-                }
-                Dictionary1[key1] = value;
-                Dictionary2[key2] = value;
-                LLUDPClient[] oldArray = Array;
-                int oldLength = oldArray.Length;
-                LLUDPClient[] newArray = new LLUDPClient[oldLength + 1];
-                for (int i = 0; i < oldLength; i++)
-                    newArray[i] = oldArray[i];
-                newArray[oldLength] = value;
-                Array = newArray;
-            }
-        }
-        public bool Remove(UUID key1, IPEndPoint key2)
-        {
-            //rwLock.EnterWriteLock();
-            //try
-            //{
-            //    LLUDPClient value;
-            //    if (Dictionary1.TryGetValue(key1, out value))
-            //    {
-            //        Dictionary1.Remove(key1);
-            //        Dictionary2.Remove(key2);
-            //        LLUDPClient[] oldArray = Array;
-            //        int oldLength = oldArray.Length;
-            //        LLUDPClient[] newArray = new LLUDPClient[oldLength - 1];
-            //        int j = 0;
-            //        for (int i = 0; i < oldLength; i++)
-            //        {
-            //            if (oldArray[i] != value)
-            //                newArray[j++] = oldArray[i];
-            //        }
-            //        Array = newArray;
-            //        return true;
-            //    }
-            //}
-            //finally { rwLock.ExitWriteLock(); }
-            //return false;
-            lock (m_sync)
-            {
-                LLUDPClient value;
-                if (Dictionary1.TryGetValue(key1, out value))
-                {
-                    Dictionary1.Remove(key1);
-                    Dictionary2.Remove(key2);
-                    LLUDPClient[] oldArray = Array;
-                    int oldLength = oldArray.Length;
-                    LLUDPClient[] newArray = new LLUDPClient[oldLength - 1];
-                    int j = 0;
-                    for (int i = 0; i < oldLength; i++)
-                    {
-                        if (oldArray[i] != value)
-                            newArray[j++] = oldArray[i];
-                    }
-                    Array = newArray;
-                    return true;
-                }
-            }
-            return false;
-        }
-        public void Clear()
-        {
-            //rwLock.EnterWriteLock();
-            //try
-            //{
-            //    Dictionary1.Clear();
-            //    Dictionary2.Clear();
-            //    Array = new LLUDPClient[0];
-            //}
-            //finally { rwLock.ExitWriteLock(); }
-            lock (m_sync)
-            {
-                Dictionary1.Clear();
-                Dictionary2.Clear();
-                Array = new LLUDPClient[0];
-            }
-        }
-        public int Count
-        {
-            get { return Array.Length; }
-        }
-        public bool ContainsKey(UUID key)
-        {
-            return Dictionary1.ContainsKey(key);
-        }
-        public bool ContainsKey(IPEndPoint key)
-        {
-            return Dictionary2.ContainsKey(key);
-        }
-        public bool TryGetValue(UUID key, out LLUDPClient value)
-        {
-            ////bool success;
-            ////bool doLock = !rwLock.IsUpgradeableReadLockHeld;
-            ////if (doLock) rwLock.EnterReadLock();
-            ////try { success = Dictionary1.TryGetValue(key, out value); }
-            ////finally { if (doLock) rwLock.ExitReadLock(); }
-            ////return success;
-            lock (m_sync)
-                return Dictionary1.TryGetValue(key, out value); 
-            //try
-            //{
-            //    return Dictionary1.TryGetValue(key, out value);
-            //}
-            //catch { }
-            //value = null;
-            //return false;
-        }
-        public bool TryGetValue(IPEndPoint key, out LLUDPClient value)
-        {
-            ////bool success;
-            ////bool doLock = !rwLock.IsUpgradeableReadLockHeld;
-            ////if (doLock) rwLock.EnterReadLock();
-            ////try { success = Dictionary2.TryGetValue(key, out value); }
-            ////finally { if (doLock) rwLock.ExitReadLock(); }
-            ////return success;
-            lock (m_sync)
-                return Dictionary2.TryGetValue(key, out value);
-            //try
-            //{
-            //    return Dictionary2.TryGetValue(key, out value);
-            //}
-            //catch { }
-            //value = null;
-            //return false;
-        }
-        public void ForEach(Action<LLUDPClient> action)
-        {
-            //bool doLock = !rwLock.IsUpgradeableReadLockHeld;
-            //if (doLock) rwLock.EnterUpgradeableReadLock();
-            //try { Parallel.ForEach<LLUDPClient>(Array, action); }
-            //finally { if (doLock) rwLock.ExitUpgradeableReadLock(); }
-            LLUDPClient[] localArray = null;
-            lock (m_sync)
-            {
-                localArray = new LLUDPClient[Array.Length];
-                Array.CopyTo(localArray, 0);
-            }
-            Parallel.ForEach<LLUDPClient>(localArray, action); 
-        }
-    }
-}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
index c356f02..890f701 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
@@ -96,7 +96,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        /// <summary>Incoming packets that are awaiting handling</summary>
        private OpenMetaverse.BlockingQueue<IncomingPacket> packetInbox = new OpenMetaverse.BlockingQueue<IncomingPacket>();
        /// <summary></summary>
-        private UDPClientCollection clients = new UDPClientCollection();
+        //private UDPClientCollection m_clients = new UDPClientCollection();
        /// <summary>Bandwidth throttle for this UDP server</summary>
        private TokenBucket m_throttle;
        /// <summary>Bandwidth throttle rates for this UDP server</summary>
@@ -109,13 +109,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        private Location m_location;
        /// <summary>The measured resolution of Environment.TickCount</summary>
        private float m_tickCountResolution;
+        /// <summary>The size of the receive buffer for the UDP socket. This value
+        /// is passed up to the operating system and used in the system networking
+        /// stack. Use zero to leave this value as the default</summary>
+        private int m_recvBufferSize;
        /// <summary>The measured resolution of Environment.TickCount</summary>
        public float TickCountResolution { get { return m_tickCountResolution; } }
        public Socket Server { get { return null; } }
        public LLUDPServer(IPAddress listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port, IConfigSource configSource, AgentCircuitManager circuitManager)
-            : base((int)port)
+            : base(listenIP, (int)port)
        {
            #region Environment.TickCount Measurement
@@ -134,18 +138,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            #endregion Environment.TickCount Measurement
            m_circuitManager = circuitManager;
+            int sceneThrottleBps = 0;
-            // TODO: Config support for throttling the entire connection
+            IConfig config = configSource.Configs["ClientStack.LindenUDP"];
-            m_throttle = new TokenBucket(null, 0, 0);
+            if (config != null)
+            {
+                m_recvBufferSize = config.GetInt("client_socket_rcvbuf_size", 0);
+                sceneThrottleBps = config.GetInt("scene_throttle_max_bps", 0);
+            }
+            m_throttle = new TokenBucket(null, sceneThrottleBps, sceneThrottleBps);
            m_throttleRates = new ThrottleRates(configSource);
        }
-        public new void Start()
+        public void Start()
        {
            if (m_scene == null)
-                throw new InvalidOperationException("Cannot LLUDPServer.Start() without an IScene reference");
+                throw new InvalidOperationException("[LLUDPSERVER]: Cannot LLUDPServer.Start() without an IScene reference");
-            base.Start();
+            base.Start(m_recvBufferSize);
            // Start the incoming packet processing thread
            Thread incomingThread = new Thread(IncomingPacketHandler);
@@ -181,24 +192,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            return x == m_location;
        }
-        public void RemoveClient(IClientAPI client)
-        {
-            m_scene.ClientManager.Remove(client.CircuitCode);
-            client.Close(false);
-            LLUDPClient udpClient;
-            if (clients.TryGetValue(client.AgentId, out udpClient))
-            {
-                m_log.Debug("[LLUDPSERVER]: Removing LLUDPClient for " + client.Name + " in " + m_scene.RegionInfo.RegionName);
-                udpClient.Shutdown();
-                clients.Remove(client.AgentId, udpClient.RemoteEndPoint);
-            }
-            else
-            {
-                m_log.Warn("[LLUDPSERVER]: Failed to remove LLUDPClient for " + client.Name);
-            }
-        }
        public void BroadcastPacket(Packet packet, ThrottleOutPacketType category, bool sendToPausedAgents, bool allowSplitting)
        {
            // CoarseLocationUpdate packets cannot be split in an automated way
@@ -216,30 +209,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                for (int i = 0; i < packetCount; i++)
                {
                    byte[] data = datas[i];
-                    clients.ForEach(
+                    m_scene.ClientManager.ForEach(
-                        delegate(LLUDPClient client)
+                        delegate(IClientAPI client)
-                        { SendPacketData(client, data, data.Length, packet.Type, packet.Header.Zerocoded, category); });
+                        {
+                            if (client is LLClientView)
+                                SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category);
+                        }
+                    );
                }
            }
            else
            {
                byte[] data = packet.ToBytes();
-                clients.ForEach(
+                m_scene.ClientManager.ForEach(
-                    delegate(LLUDPClient client)
+                    delegate(IClientAPI client)
-                    { SendPacketData(client, data, data.Length, packet.Type, packet.Header.Zerocoded, category); });
+                    {
+                        if (client is LLClientView)
+                            SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category);
+                    }
+                );
            }
        }
-        public void SendPacket(UUID agentID, Packet packet, ThrottleOutPacketType category, bool allowSplitting)
+        public void SendPacket(LLUDPClient udpClient, Packet packet, ThrottleOutPacketType category, bool allowSplitting)
-        {
-            LLUDPClient client;
-            if (clients.TryGetValue(agentID, out client))
-                SendPacket(client, packet, category, allowSplitting);
-            else
-                m_log.Warn("[LLUDPSERVER]: Attempted to send a packet to unknown agentID " + agentID);
-        }
-        public void SendPacket(LLUDPClient client, Packet packet, ThrottleOutPacketType category, bool allowSplitting)
        {
            // CoarseLocationUpdate packets cannot be split in an automated way
            if (packet.Type == PacketType.CoarseLocationUpdate && allowSplitting)
@@ -256,25 +248,28 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                for (int i = 0; i < packetCount; i++)
                {
                    byte[] data = datas[i];
-                    SendPacketData(client, data, data.Length, packet.Type, packet.Header.Zerocoded, category);
+                    SendPacketData(udpClient, data, packet.Type, category);
                }
            }
            else
            {
                byte[] data = packet.ToBytes();
-                SendPacketData(client, data, data.Length, packet.Type, packet.Header.Zerocoded, category);
+                SendPacketData(udpClient, data, packet.Type, category);
            }
        }
-        public void SendPacketData(LLUDPClient client, byte[] data, int dataLength, PacketType type, bool doZerocode, ThrottleOutPacketType category)
+        public void SendPacketData(LLUDPClient udpClient, byte[] data, PacketType type, ThrottleOutPacketType category)
        {
+            int dataLength = data.Length;
+            bool doZerocode = (data[0] & Helpers.MSG_ZEROCODED) != 0;
            // Frequency analysis of outgoing packet sizes shows a large clump of packets at each end of the spectrum.
            // The vast majority of packets are less than 200 bytes, although due to asset transfers and packet splitting
            // there are a decent number of packets in the 1000-1140 byte range. We allocate one of two sizes of data here
            // to accomodate for both common scenarios and provide ample room for ACK appending in both
            int bufferSize = (dataLength > 180) ? Packet.MTU : 200;
-            UDPPacketBuffer buffer = new UDPPacketBuffer(client.RemoteEndPoint, bufferSize);
+            UDPPacketBuffer buffer = new UDPPacketBuffer(udpClient.RemoteEndPoint, bufferSize);
            // Zerocode if needed
            if (doZerocode)
@@ -285,17 +280,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                    // The packet grew larger than the bufferSize while zerocoding.
                    // Remove the MSG_ZEROCODED flag and send the unencoded data
                    // instead
-                    m_log.Info("[LLUDPSERVER]: Packet exceeded buffer size during zerocoding. Removing MSG_ZEROCODED flag");
+                    m_log.Debug("[LLUDPSERVER]: Packet exceeded buffer size during zerocoding for " + type + ". Removing MSG_ZEROCODED flag");
                    data[0] = (byte)(data[0] & ~Helpers.MSG_ZEROCODED);
-                    //
-                    buffer = new UDPPacketBuffer(client.RemoteEndPoint, dataLength);
-                    //
                    Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
                }
            }
            else
            {
-                // ??? will it fit?
                Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
            }
            buffer.DataLength = dataLength;
@@ -303,7 +294,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            #region Queue or Send
            // Look up the UDPClient this is going to
-            OutgoingPacket outgoingPacket = new OutgoingPacket(client, buffer, category);
+            OutgoingPacket outgoingPacket = new OutgoingPacket(udpClient, buffer, category);
            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
                SendPacketFinal(outgoingPacket);
@@ -311,18 +302,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            #endregion Queue or Send
        }
-        public void SendAcks(LLUDPClient client)
+        public void SendAcks(LLUDPClient udpClient)
        {
            uint ack;
-            if (client.PendingAcks.Dequeue(out ack))
+            if (udpClient.PendingAcks.Dequeue(out ack))
            {
                List<PacketAckPacket.PacketsBlock> blocks = new List<PacketAckPacket.PacketsBlock>();
                PacketAckPacket.PacketsBlock block = new PacketAckPacket.PacketsBlock();
                block.ID = ack;
                blocks.Add(block);
-                while (client.PendingAcks.Dequeue(out ack))
+                while (udpClient.PendingAcks.Dequeue(out ack))
                {
                    block = new PacketAckPacket.PacketsBlock();
                    block.ID = ack;
@@ -333,22 +324,39 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                packet.Header.Reliable = false;
                packet.Packets = blocks.ToArray();
-                SendPacket(client, packet, ThrottleOutPacketType.Unknown, true);
+                SendPacket(udpClient, packet, ThrottleOutPacketType.Unknown, true);
            }
        }
-        public void SendPing(LLUDPClient client)
+        public void SendPing(LLUDPClient udpClient)
        {
-            IClientAPI api = client.ClientAPI;
+            StartPingCheckPacket pc = (StartPingCheckPacket)PacketPool.Instance.GetPacket(PacketType.StartPingCheck);
-            if (api != null)
+            pc.Header.Reliable = false;
-                api.SendStartPingCheck(client.CurrentPingSequence++);
+            OutgoingPacket oldestPacket = udpClient.NeedAcks.GetOldest();
+            pc.PingID.PingID = (byte)udpClient.CurrentPingSequence++;
+            pc.PingID.OldestUnacked = (oldestPacket != null) ? oldestPacket.SequenceNumber : 0;
+            SendPacket(udpClient, pc, ThrottleOutPacketType.Unknown, false);
        }
-        public void ResendUnacked(LLUDPClient client)
+        public void ResendUnacked(LLUDPClient udpClient)
        {
-            if (client.NeedAcks.Count > 0)
+            if (udpClient.IsConnected && udpClient.NeedAcks.Count > 0)
            {
-                List<OutgoingPacket> expiredPackets = client.NeedAcks.GetExpiredPackets(client.RTO);
+                // Disconnect an agent if no packets are received for some time
+                //FIXME: Make 60 an .ini setting
+                if (Environment.TickCount - udpClient.TickLastPacketReceived > 1000 * 60)
+                {
+                    m_log.Warn("[LLUDPSERVER]: Ack timeout, disconnecting " + udpClient.AgentID);
+                    RemoveClient(udpClient);
+                    return;
+                }
+                // Get a list of all of the packets that have been sitting unacked longer than udpClient.RTO
+                List<OutgoingPacket> expiredPackets = udpClient.NeedAcks.GetExpiredPackets(udpClient.RTO);
                if (expiredPackets != null)
                {
@@ -357,54 +365,30 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                    {
                        OutgoingPacket outgoingPacket = expiredPackets[i];
-                        // FIXME: Make this an .ini setting
+                        //m_log.DebugFormat("[LLUDPSERVER]: Resending packet #{0} (attempt {1}), {2}ms have passed",
-                        if (outgoingPacket.ResendCount < 3)
+                        //    outgoingPacket.SequenceNumber, outgoingPacket.ResendCount, Environment.TickCount - outgoingPacket.TickCount);
-                        {
-                            //Logger.Debug(String.Format("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;
-                            // The TickCount will be set to the current time when the packet
+                        // Set the resent flag
-                            // is actually sent out again
+                        outgoingPacket.Buffer.Data[0] = (byte)(outgoingPacket.Buffer.Data[0] | Helpers.MSG_RESENT);
-                            outgoingPacket.TickCount = 0;
+                        outgoingPacket.Category = ThrottleOutPacketType.Resend;
-                            // Bump up the resend count on this packet
+                        // The TickCount will be set to the current time when the packet
-                            Interlocked.Increment(ref outgoingPacket.ResendCount);
+                        // is actually sent out again
-                            //Interlocked.Increment(ref Stats.ResentPackets);
+                        outgoingPacket.TickCount = 0;
-                            // Queue or (re)send the packet
+                        // Bump up the resend count on this packet
-                            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
+                        Interlocked.Increment(ref outgoingPacket.ResendCount);
-                                SendPacketFinal(outgoingPacket);
+                        //Interlocked.Increment(ref Stats.ResentPackets);
-                        }
-                        else
-                        {
-                            m_log.DebugFormat("[LLUDPSERVER]: Dropping packet #{0} for agent {1} after {2} failed attempts",
-                                outgoingPacket.SequenceNumber, outgoingPacket.Client.RemoteEndPoint, outgoingPacket.ResendCount);
-                            lock (client.NeedAcks.SyncRoot)
+                        // Requeue or resend the packet
-                                client.NeedAcks.RemoveUnsafe(outgoingPacket.SequenceNumber);
+                        if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
+                            SendPacketFinal(outgoingPacket);
-                            //Interlocked.Increment(ref Stats.DroppedPackets);
-                            // Disconnect an agent if no packets are received for some time
-                            //FIXME: Make 60 an .ini setting
-                            if (Environment.TickCount - client.TickLastPacketReceived > 1000 * 60)
-                            {
-                                m_log.Warn("[LLUDPSERVER]: Ack timeout, disconnecting " + client.ClientAPI.Name);
-                                RemoveClient(client.ClientAPI);
-                                return;
-                            }
-                        }
                    }
                }
            }
        }
-        public void Flush()
+        public void Flush(LLUDPClient udpClient)
        {
            // FIXME: Implement?
        }
@@ -415,7 +399,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            byte flags = buffer.Data[0];
            bool isResend = (flags & Helpers.MSG_RESENT) != 0;
            bool isReliable = (flags & Helpers.MSG_RELIABLE) != 0;
-            LLUDPClient client = outgoingPacket.Client;
+            LLUDPClient udpClient = outgoingPacket.Client;
+            if (!udpClient.IsConnected)
+                return;
            // Keep track of when this packet was sent out (right now)
            outgoingPacket.TickCount = Environment.TickCount;
@@ -424,11 +411,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            int dataLength = buffer.DataLength;
-            // Keep appending ACKs until there is no room left in the packet or there are
+            // Keep appending ACKs until there is no room left in the buffer or there are
            // no more ACKs to append
            uint ackCount = 0;
            uint ack;
-            while (dataLength + 5 < buffer.Data.Length && client.PendingAcks.Dequeue(out ack))
+            while (dataLength + 5 < buffer.Data.Length && udpClient.PendingAcks.Dequeue(out ack))
            {
                Utils.UIntToBytesBig(ack, buffer.Data, dataLength);
                dataLength += 4;
@@ -447,24 +434,28 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            #endregion ACK Appending
+            #region Sequence Number Assignment
            if (!isResend)
            {
                // Not a resend, assign a new sequence number
-                uint sequenceNumber = (uint)Interlocked.Increment(ref client.CurrentSequence);
+                uint sequenceNumber = (uint)Interlocked.Increment(ref udpClient.CurrentSequence);
                Utils.UIntToBytesBig(sequenceNumber, buffer.Data, 1);
                outgoingPacket.SequenceNumber = sequenceNumber;
                if (isReliable)
                {
                    // Add this packet to the list of ACK responses we are waiting on from the server
-                    client.NeedAcks.Add(outgoingPacket);
+                    udpClient.NeedAcks.Add(outgoingPacket);
                }
            }
+            #endregion Sequence Number Assignment
            // Stats tracking
-            Interlocked.Increment(ref client.PacketsSent);
+            Interlocked.Increment(ref udpClient.PacketsSent);
            if (isReliable)
-                Interlocked.Add(ref client.UnackedBytes, outgoingPacket.Buffer.DataLength);
+                Interlocked.Add(ref udpClient.UnackedBytes, outgoingPacket.Buffer.DataLength);
            // Put the UDP payload on the wire
            AsyncBeginSend(buffer);
@@ -473,10 +464,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        protected override void PacketReceived(UDPPacketBuffer buffer)
        {
            // Debugging/Profiling
-            //try { Thread.CurrentThread.Name = "PacketReceived (" + scene.RegionName + ")"; }
+            //try { Thread.CurrentThread.Name = "PacketReceived (" + m_scene.RegionInfo.RegionName + ")"; }
            //catch (Exception) { }
-            LLUDPClient client = null;
+            LLUDPClient udpClient = null;
            Packet packet = null;
            int packetEnd = buffer.DataLength - 1;
            IPEndPoint address = (IPEndPoint)buffer.RemoteEndPoint;
@@ -491,61 +482,59 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            }
            catch (MalformedDataException)
            {
-                m_log.ErrorFormat("[LLUDPSERVER]: Malformed data, cannot parse packet:\n{0}",
+                m_log.ErrorFormat("[LLUDPSERVER]: Malformed data, cannot parse packet from {0}:\n{1}",
-                    Utils.BytesToHexString(buffer.Data, buffer.DataLength, null));
+                    buffer.RemoteEndPoint, Utils.BytesToHexString(buffer.Data, buffer.DataLength, null));
            }
            // Fail-safe check
            if (packet == null)
            {
-                m_log.Warn("[LLUDPSERVER]: Couldn't build a message from the incoming data");
+                m_log.Warn("[LLUDPSERVER]: Couldn't build a message from incoming data " + buffer.DataLength +
+                    " bytes long from " + buffer.RemoteEndPoint);
                return;
            }
-            //Stats.RecvBytes += (ulong)buffer.DataLength;
-            //++Stats.RecvPackets;
            #endregion Decoding
-            #region UseCircuitCode Handling
+            #region Packet to Client Mapping
+            // UseCircuitCode handling
            if (packet.Type == PacketType.UseCircuitCode)
            {
-                UseCircuitCodePacket useCircuitCode = (UseCircuitCodePacket)packet;
+                AddNewClient((UseCircuitCodePacket)packet, (IPEndPoint)buffer.RemoteEndPoint);
-                IClientAPI newuser;
-                uint circuitCode = useCircuitCode.CircuitCode.Code;
-                // Check if the client is already established
-                if (!m_scene.ClientManager.TryGetClient(circuitCode, out newuser))
-                {
-                    AddNewClient(useCircuitCode, (IPEndPoint)buffer.RemoteEndPoint);
-                }
            }
            // Determine which agent this packet came from
-            if (!clients.TryGetValue(address, out client))
+            IClientAPI client;
+            if (!m_scene.ClientManager.TryGetValue(address, out client) || !(client is LLClientView))
            {
-                m_log.Warn("[LLUDPSERVER]: Received a " + packet.Type + " packet from an unrecognized source: " + address + " in " + m_scene.RegionInfo.RegionName);
+                m_log.Warn("[LLUDPSERVER]: Received a " + packet.Type + " packet from an unrecognized source: " + address +
+                    " in " + m_scene.RegionInfo.RegionName + ", currently tracking " + m_scene.ClientManager.Count + " clients");
                return;
            }
-            #endregion UseCircuitCode Handling
+            udpClient = ((LLClientView)client).UDPClient;
+            if (!udpClient.IsConnected)
+                return;
+            #endregion Packet to Client Mapping
            // Stats tracking
-            Interlocked.Increment(ref client.PacketsReceived);
+            Interlocked.Increment(ref udpClient.PacketsReceived);
            #region ACK Receiving
            int now = Environment.TickCount;
-            client.TickLastPacketReceived = now;
+            udpClient.TickLastPacketReceived = now;
            // Handle appended ACKs
            if (packet.Header.AppendedAcks && packet.Header.AckList != null)
            {
-                lock (client.NeedAcks.SyncRoot)
+                lock (udpClient.NeedAcks.SyncRoot)
                {
                    for (int i = 0; i < packet.Header.AckList.Length; i++)
-                        AcknowledgePacket(client, packet.Header.AckList[i], now, packet.Header.Resent);
+                        AcknowledgePacket(udpClient, packet.Header.AckList[i], now, packet.Header.Resent);
                }
            }
@@ -554,10 +543,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            {
                PacketAckPacket ackPacket = (PacketAckPacket)packet;
-                lock (client.NeedAcks.SyncRoot)
+                lock (udpClient.NeedAcks.SyncRoot)
                {
                    for (int i = 0; i < ackPacket.Packets.Length; i++)
-                        AcknowledgePacket(client, ackPacket.Packets[i].ID, now, packet.Header.Resent);
+                        AcknowledgePacket(udpClient, ackPacket.Packets[i].ID, now, packet.Header.Resent);
                }
            }
@@ -566,27 +555,27 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            #region ACK Sending
            if (packet.Header.Reliable)
-                client.PendingAcks.Enqueue((uint)packet.Header.Sequence);
+                udpClient.PendingAcks.Enqueue(packet.Header.Sequence);
            // This is a somewhat odd sequence of steps to pull the client.BytesSinceLastACK value out,
            // add the current received bytes to it, test if 2*MTU bytes have been sent, if so remove
            // 2*MTU bytes from the value and send ACKs, and finally add the local value back to
            // client.BytesSinceLastACK. Lockless thread safety
-            int bytesSinceLastACK = Interlocked.Exchange(ref client.BytesSinceLastACK, 0);
+            int bytesSinceLastACK = Interlocked.Exchange(ref udpClient.BytesSinceLastACK, 0);
            bytesSinceLastACK += buffer.DataLength;
            if (bytesSinceLastACK > Packet.MTU * 2)
            {
                bytesSinceLastACK -= Packet.MTU * 2;
-                SendAcks(client);
+                SendAcks(udpClient);
            }
-            Interlocked.Add(ref client.BytesSinceLastACK, bytesSinceLastACK);
+            Interlocked.Add(ref udpClient.BytesSinceLastACK, bytesSinceLastACK);
            #endregion ACK Sending
            #region Incoming Packet Accounting
            // Check the archive of received reliable packet IDs to see whether we already received this packet
-            if (packet.Header.Reliable && !client.PacketArchive.TryEnqueue(packet.Header.Sequence))
+            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);
@@ -603,7 +592,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            if (packet.Type != PacketType.PacketAck)
            {
                // Inbox insertion
-                packetInbox.Enqueue(new IncomingPacket(client, packet));
+                packetInbox.Enqueue(new IncomingPacket(udpClient, packet));
            }
        }
@@ -623,53 +612,59 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        private void AddNewClient(UseCircuitCodePacket useCircuitCode, IPEndPoint remoteEndPoint)
        {
-            //Slave regions don't accept new clients
+            UUID agentID = useCircuitCode.CircuitCode.ID;
+            UUID sessionID = useCircuitCode.CircuitCode.SessionID;
+            uint circuitCode = useCircuitCode.CircuitCode.Code;
            if (m_scene.RegionStatus != RegionStatus.SlaveScene)
            {
                AuthenticateResponse sessionInfo;
-                bool isNewCircuit = !clients.ContainsKey(remoteEndPoint);
+                if (IsClientAuthorized(useCircuitCode, out sessionInfo))
-                if (!IsClientAuthorized(useCircuitCode, out sessionInfo))
                {
-                    m_log.WarnFormat(
+                    AddClient(circuitCode, agentID, sessionID, remoteEndPoint, sessionInfo);
-                        "[CONNECTION FAILURE]: Connection request for client {0} connecting with unnotified circuit code {1} from {2}",
-                        useCircuitCode.CircuitCode.ID, useCircuitCode.CircuitCode.Code, remoteEndPoint);
-                    return;
                }
+                else
-                if (isNewCircuit)
                {
-                    UUID agentID = useCircuitCode.CircuitCode.ID;
+                    // Don't create circuits for unauthorized clients
-                    UUID sessionID = useCircuitCode.CircuitCode.SessionID;
+                    m_log.WarnFormat(
-                    uint circuitCode = useCircuitCode.CircuitCode.Code;
+                        "[LLUDPSERVER]: Connection request for client {0} connecting with unnotified circuit code {1} from {2}",
+                        useCircuitCode.CircuitCode.ID, useCircuitCode.CircuitCode.Code, remoteEndPoint);
-                    AddClient(circuitCode, agentID, sessionID, remoteEndPoint, sessionInfo);
                }
            }
+            else
+            {
+                // Slave regions don't accept new clients
+                m_log.Debug("[LLUDPSERVER]: Slave region " + m_scene.RegionInfo.RegionName + " ignoring UseCircuitCode packet");
+            }
        }
        private void AddClient(uint circuitCode, UUID agentID, UUID sessionID, IPEndPoint remoteEndPoint, AuthenticateResponse sessionInfo)
        {
            // Create the LLUDPClient
-            LLUDPClient client = new LLUDPClient(this, m_throttleRates, m_throttle, circuitCode, agentID, remoteEndPoint);
+            LLUDPClient udpClient = new LLUDPClient(this, m_throttleRates, m_throttle, circuitCode, agentID, remoteEndPoint);
-            // Create the LLClientView
-            LLClientView clientApi = new LLClientView(remoteEndPoint, m_scene, this, client, sessionInfo, agentID, sessionID, circuitCode);
-            clientApi.OnViewerEffect += m_scene.ClientManager.ViewerEffectHandler;
-            clientApi.OnLogout += LogoutHandler;
-            clientApi.OnConnectionClosed += RemoveClient;
-            // Start the IClientAPI
-            m_scene.ClientManager.Add(circuitCode, clientApi);
-            clientApi.Start();
-            // Give LLUDPClient a reference to IClientAPI
+            if (!m_scene.ClientManager.ContainsKey(agentID))
-            client.ClientAPI = clientApi;
+            {
+                // Create the LLClientView
+                LLClientView client = new LLClientView(remoteEndPoint, m_scene, this, udpClient, sessionInfo, agentID, sessionID, circuitCode);
+                client.OnLogout += LogoutHandler;
-            // Add the new client to our list of tracked clients
+                // Start the IClientAPI
-            clients.Add(agentID, client.RemoteEndPoint, client);
+                client.Start();
+            }
+            else
+            {
+                m_log.WarnFormat("[LLUDPSERVER]: Ignoring a repeated UseCircuitCode from {0} at {1} for circuit {2}",
+                    udpClient.AgentID, remoteEndPoint, circuitCode);
+            }
+        }
-            m_log.DebugFormat("[LLUDPSERVER]: Added new client {0} to region {1}", agentID, m_scene.RegionInfo.RegionName);
+        private void RemoveClient(LLUDPClient udpClient)
+        {
+            // Remove this client from the scene
+            IClientAPI client;
+            if (m_scene.ClientManager.TryGetValue(udpClient.AgentID, out client))
+                client.Close();
        }
        private void AcknowledgePacket(LLUDPClient client, uint ack, int currentTime, bool fromResend)
@@ -747,20 +742,28 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                    elapsed500MS = 0;
                }
-                clients.ForEach(
+                m_scene.ClientManager.ForEach(
-                    delegate(LLUDPClient client)
+                    delegate(IClientAPI client)
                    {
-                        if (client.DequeueOutgoing())
+                        if (client is LLClientView)
-                            packetSent = true;
-                        if (resendUnacked)
-                            ResendUnacked(client);
-                        if (sendAcks)
                        {
-                            SendAcks(client);
+                            LLUDPClient udpClient = ((LLClientView)client).UDPClient;
-                            client.SendPacketStats();
+                            if (udpClient.IsConnected)
+                            {
+                                if (udpClient.DequeueOutgoing())
+                                    packetSent = true;
+                                if (resendUnacked)
+                                    ResendUnacked(udpClient);
+                                if (sendAcks)
+                                {
+                                    SendAcks(udpClient);
+                                    udpClient.SendPacketStats();
+                                }
+                                if (sendPings)
+                                    SendPing(udpClient);
+                            }
                        }
-                        if (sendPings)
-                            SendPing(client);
                    }
                );
@@ -773,38 +776,48 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        {
            IncomingPacket incomingPacket = (IncomingPacket)state;
            Packet packet = incomingPacket.Packet;
-            LLUDPClient client = incomingPacket.Client;
+            LLUDPClient udpClient = incomingPacket.Client;
+            IClientAPI client;
            // Sanity check
-            if (packet == null || client == null || client.ClientAPI == null)
+            if (packet == null || udpClient == null)
            {
-                m_log.WarnFormat("[LLUDPSERVER]: Processing a packet with incomplete state. Packet=\"{0}\", Client=\"{1}\", Client.ClientAPI=\"{2}\"",
+                m_log.WarnFormat("[LLUDPSERVER]: Processing a packet with incomplete state. Packet=\"{0}\", UDPClient=\"{1}\"",
-                    packet, client, (client != null) ? client.ClientAPI : null);
+                    packet, udpClient);
            }
-            try
+            // Make sure this client is still alive
-            {
+            if (m_scene.ClientManager.TryGetValue(udpClient.AgentID, out client))
-                // Process this packet
-                client.ClientAPI.ProcessInPacket(packet);
-            }
-            catch (ThreadAbortException)
            {
-                // If something is trying to abort the packet processing thread, take that as a hint that it's time to shut down
+                try
-                m_log.Info("[LLUDPSERVER]: Caught a thread abort, shutting down the LLUDP server");
+                {
-                Stop();
+                    // Process this packet
+                    client.ProcessInPacket(packet);
+                }
+                catch (ThreadAbortException)
+                {
+                    // If something is trying to abort the packet processing thread, take that as a hint that it's time to shut down
+                    m_log.Info("[LLUDPSERVER]: Caught a thread abort, shutting down the LLUDP server");
+                    Stop();
+                }
+                catch (Exception e)
+                {
+                    // Don't let a failure in an individual client thread crash the whole sim.
+                    m_log.ErrorFormat("[LLUDPSERVER]: Client packet handler for {0} for packet {1} threw an exception", udpClient.AgentID, packet.Type);
+                    m_log.Error(e.Message, e);
+                }
            }
-            catch (Exception e)
+            else
            {
-                // Don't let a failure in an individual client thread crash the whole sim.
+                m_log.DebugFormat("[LLUDPSERVER]: Dropping incoming {0} packet for dead client {1}", packet.Type, udpClient.AgentID);
-                m_log.ErrorFormat("[LLUDPSERVER]: Client packet handler for {0} for packet {1} threw an exception", client.AgentID, packet.Type);
-                m_log.Error(e.Message, e);
            }
        }
        private void LogoutHandler(IClientAPI client)
        {
            client.SendLogoutPacket();
-            RemoveClient(client);
+            if (client.IsActive)
+                RemoveClient(((LLClientView)client).UDPClient);
        }
    }
 }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
index 43a68ec..44a6ed6 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
@@ -1,419 +1,129 @@
-//--------- Modified Version -------------------
+/*
-///*
+ * Copyright (c) 2006, Clutch, Inc.
-// * Copyright (c) 2006, Clutch, Inc.
+ * Original Author: Jeff Cesnik
-// * Original Author: Jeff Cesnik
+ * All rights reserved.
-// * All rights reserved.
+ *
-// *
+ * - Redistribution and use in source and binary forms, with or without 
-// * - Redistribution and use in source and binary forms, with or without 
+ *   modification, are permitted provided that the following conditions are met:
-// *   modification, are permitted provided that the following conditions are met:
+ *
-// *
+ * - Redistributions of source code must retain the above copyright notice, this
-// * - Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
-// *   list of conditions and the following disclaimer.
+ * - Neither the name of the openmetaverse.org nor the names 
-// * - Neither the name of the openmetaverse.org nor the names 
+ *   of its contributors may be used to endorse or promote products derived from
-// *   of its contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
-// *   this software without specific prior written permission.
+ *
-// *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
-// * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-// * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
-// * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
-// * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
-// * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
-// * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
-// * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
-// * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
-// * 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 
-// * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ * POSSIBILITY OF SUCH DAMAGE.
-// * POSSIBILITY OF SUCH DAMAGE.
+ */
-// */
 using System;
 using System.Net;
 using System.Net.Sockets;
 using System.Threading;
-using OpenMetaverse;
+using log4net;
-//namespace OpenSim.Region.ClientStack.LindenUDP
+namespace OpenMetaverse
-//{
-//    /// <summary>
-//    /// 
-//    /// </summary>
-//    public abstract class OpenSimUDPBase
-//    {
-//        // these abstract methods must be implemented in a derived class to actually do
-//        // something with the packets that are sent and received.
-//        protected abstract void PacketReceived(UDPPacketBuffer buffer);
-//        protected abstract void PacketSent(UDPPacketBuffer buffer, int bytesSent);
-//        // the port to listen on
-//        internal int udpPort;
-//        // the UDP socket
-//        private Socket udpSocket;
-//        // the ReaderWriterLock is used solely for the purposes of shutdown (Stop()).
-//        // since there are potentially many "reader" threads in the internal .NET IOCP
-//        // thread pool, this is a cheaper synchronization primitive than using
-//        // a Mutex object.  This allows many UDP socket "reads" concurrently - when
-//        // Stop() is called, it attempts to obtain a writer lock which will then
-//        // wait until all outstanding operations are completed before shutting down.
-//        // this avoids the problem of closing the socket with outstanding operations
-//        // and trying to catch the inevitable ObjectDisposedException.
-//        private ReaderWriterLock rwLock = new ReaderWriterLock();
-//        // number of outstanding operations.  This is a reference count
-//        // which we use to ensure that the threads exit cleanly. Note that
-//        // we need this because the threads will potentially still need to process
-//        // data even after the socket is closed.
-//        private int rwOperationCount = 0;
-//        // the all important shutdownFlag.  This is synchronized through the ReaderWriterLock.
-//        private volatile bool shutdownFlag = true;
-//        // the remote endpoint to communicate with
-//        protected IPEndPoint remoteEndPoint = null;
-//        /// <summary>
-//        /// Initialize the UDP packet handler in server mode
-//        /// </summary>
-//        /// <param name="port">Port to listening for incoming UDP packets on</param>
-//        public OpenSimUDPBase(int port)
-//        {
-//            udpPort = port;
-//        }
-//        /// <summary>
-//        /// Initialize the UDP packet handler in client mode
-//        /// </summary>
-//        /// <param name="endPoint">Remote UDP server to connect to</param>
-//        public OpenSimUDPBase(IPEndPoint endPoint)
-//        {
-//            remoteEndPoint = endPoint;
-//            udpPort = 0;
-//        }
-//        /// <summary>
-//        /// 
-//        /// </summary>
-//        public void Start()
-//        {
-//            if (shutdownFlag)
-//            {
-//                if (remoteEndPoint == null)
-//                {
-//                    // Server mode
-//                    // create and bind the socket
-//                    IPEndPoint ipep = new IPEndPoint(Settings.BIND_ADDR, udpPort);
-//                    udpSocket = new Socket(
-//                        AddressFamily.InterNetwork,
-//                        SocketType.Dgram,
-//                        ProtocolType.Udp);
-//                    udpSocket.Bind(ipep);
-//                }
-//                else
-//                {
-//                    // Client mode
-//                    IPEndPoint ipep = new IPEndPoint(Settings.BIND_ADDR, udpPort);
-//                    udpSocket = new Socket(
-//                        AddressFamily.InterNetwork,
-//                        SocketType.Dgram,
-//                        ProtocolType.Udp);
-//                    udpSocket.Bind(ipep);
-//                    //udpSocket.Connect(remoteEndPoint);
-//                }
-//                // we're not shutting down, we're starting up
-//                shutdownFlag = false;
-//                // kick off an async receive.  The Start() method will return, the
-//                // actual receives will occur asynchronously and will be caught in
-//                // AsyncEndRecieve().
-//                AsyncBeginReceive();
-//            }
-//        }
-//        /// <summary>
-//        /// 
-//        /// </summary>
-//        public void Stop()
-//        {
-//            if (!shutdownFlag)
-//            {
-//                // wait indefinitely for a writer lock.  Once this is called, the .NET runtime
-//                // will deny any more reader locks, in effect blocking all other send/receive
-//                // threads.  Once we have the lock, we set shutdownFlag to inform the other
-//                // threads that the socket is closed.
-//                rwLock.AcquireWriterLock(-1);
-//                shutdownFlag = true;
-//                udpSocket.Close();
-//                rwLock.ReleaseWriterLock();
-//                // wait for any pending operations to complete on other
-//                // threads before exiting.
-//                const int FORCE_STOP = 100;
-//                int i = 0;
-//                while (rwOperationCount > 0 && i < FORCE_STOP)
-//                {
-//                    Thread.Sleep(10);
-//                    ++i;
-//                }
-//                if (i >= FORCE_STOP)
-//                {
-//                    Logger.Log("UDPBase.Stop() forced shutdown while waiting on pending operations",
-//                        Helpers.LogLevel.Warning);
-//                }
-//            }
-//        }
-//        /// <summary>
-//        /// 
-//        /// </summary>
-//        public bool IsRunning
-//        {
-//            get { return !shutdownFlag; }
-//        }
-//        private void AsyncBeginReceive()
-//        {
-//            // this method actually kicks off the async read on the socket.
-//            // we aquire a reader lock here to ensure that no other thread
-//            // is trying to set shutdownFlag and close the socket.
-//            rwLock.AcquireReaderLock(-1);
-//            if (!shutdownFlag)
-//            {
-//                // increment the count of pending operations
-//                Interlocked.Increment(ref rwOperationCount);
-//                // allocate a packet buffer
-//                //WrappedObject<UDPPacketBuffer> wrappedBuffer = Pool.CheckOut();
-//                UDPPacketBuffer buf = new UDPPacketBuffer();
-//                try
-//                {
-//                    // kick off an async read
-//                    udpSocket.BeginReceiveFrom(
-//                        //wrappedBuffer.Instance.Data,
-//                        buf.Data,
-//                        0,
-//                        UDPPacketBuffer.BUFFER_SIZE,
-//                        SocketFlags.None,
-//                        //ref wrappedBuffer.Instance.RemoteEndPoint,
-//                        ref buf.RemoteEndPoint,
-//                        new AsyncCallback(AsyncEndReceive),
-//                        //wrappedBuffer);
-//                        buf);
-//                }
-//                catch (SocketException)
-//                {
-//                    // something bad happened
-//                    //Logger.Log(
-//                    //    "A SocketException occurred in UDPServer.AsyncBeginReceive()", 
-//                    //    Helpers.LogLevel.Error, se);
-//                    // an error occurred, therefore the operation is void.  Decrement the reference count.
-//                    Interlocked.Decrement(ref rwOperationCount);
-//                }
-//            }
-//            // we're done with the socket for now, release the reader lock.
-//            rwLock.ReleaseReaderLock();
-//        }
-//        private void AsyncEndReceive(IAsyncResult iar)
-//        {
-//            // Asynchronous receive operations will complete here through the call
-//            // to AsyncBeginReceive
-//            // aquire a reader lock
-//            rwLock.AcquireReaderLock(-1);
-//            if (!shutdownFlag)
-//            {
-//                // get the buffer that was created in AsyncBeginReceive
-//                // this is the received data
-//                //WrappedObject<UDPPacketBuffer> wrappedBuffer = (WrappedObject<UDPPacketBuffer>)iar.AsyncState;
-//                //UDPPacketBuffer buffer = wrappedBuffer.Instance;
-//                UDPPacketBuffer buffer = (UDPPacketBuffer)iar.AsyncState;
-//                try
-//                {
-//                    // get the length of data actually read from the socket, store it with the
-//                    // buffer
-//                    buffer.DataLength = udpSocket.EndReceiveFrom(iar, ref buffer.RemoteEndPoint);
-//                    // this operation is now complete, decrement the reference count
-//                    Interlocked.Decrement(ref rwOperationCount);
-//                    // we're done with the socket, release the reader lock
-//                    rwLock.ReleaseReaderLock();
-//                    // call the abstract method PacketReceived(), passing the buffer that
-//                    // has just been filled from the socket read.
-//                    PacketReceived(buffer);
-//                }
-//                catch (SocketException)
-//                {
-//                    // an error occurred, therefore the operation is void.  Decrement the reference count.
-//                    Interlocked.Decrement(ref rwOperationCount);
-//                    // we're done with the socket for now, release the reader lock.
-//                    rwLock.ReleaseReaderLock();
-//                }
-//                finally
-//                {
-//                    // start another receive - this keeps the server going!
-//                    AsyncBeginReceive();
-//                    //wrappedBuffer.Dispose();
-//                }
-//            }
-//            else
-//            {
-//                // nothing bad happened, but we are done with the operation
-//                // decrement the reference count and release the reader lock
-//                Interlocked.Decrement(ref rwOperationCount);
-//                rwLock.ReleaseReaderLock();
-//            }
-//        }
-//        public void AsyncBeginSend(UDPPacketBuffer buf)
-//        {
-//            rwLock.AcquireReaderLock(-1);
-//            if (!shutdownFlag)
-//            {
-//                try
-//                {
-//                    Interlocked.Increment(ref rwOperationCount);
-//                    udpSocket.BeginSendTo(
-//                        buf.Data,
-//                        0,
-//                        buf.DataLength,
-//                        SocketFlags.None,
-//                        buf.RemoteEndPoint,
-//                        new AsyncCallback(AsyncEndSend),
-//                        buf);
-//                }
-//                catch (SocketException)
-//                {
-//                    //Logger.Log(
-//                    //    "A SocketException occurred in UDPServer.AsyncBeginSend()",
-//                    //    Helpers.LogLevel.Error, se);
-//                }
-//            }
-//            rwLock.ReleaseReaderLock();
-//        }
-//        private void AsyncEndSend(IAsyncResult iar)
-//        {
-//            rwLock.AcquireReaderLock(-1);
-//            if (!shutdownFlag)
-//            {
-//                UDPPacketBuffer buffer = (UDPPacketBuffer)iar.AsyncState;
-//                try
-//                {
-//                    int bytesSent = udpSocket.EndSendTo(iar);
-//                    // note that call to the abstract PacketSent() method - we are passing the number
-//                    // of bytes sent in a separate parameter, since we can't use buffer.DataLength which
-//                    // is the number of bytes to send (or bytes received depending upon whether this
-//                    // buffer was part of a send or a receive).
-//                    PacketSent(buffer, bytesSent);
-//                }
-//                catch (SocketException)
-//                {
-//                    //Logger.Log(
-//                    //    "A SocketException occurred in UDPServer.AsyncEndSend()",
-//                    //    Helpers.LogLevel.Error, se);
-//                }
-//            }
-//            Interlocked.Decrement(ref rwOperationCount);
-//            rwLock.ReleaseReaderLock();
-//        }
-//    }
-//}
-//--------- Original Version -------------------
-namespace OpenSim.Region.ClientStack.LindenUDP
 {
    /// <summary>
-    /// 
+    /// Base UDP server
    /// </summary>
    public abstract class OpenSimUDPBase
    {
-        // these abstract methods must be implemented in a derived class to actually do
+        private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
-        // something with the packets that are sent and received.
+        /// <summary>
+        /// This method is called when an incoming packet is received
+        /// </summary>
+        /// <param name="buffer">Incoming packet buffer</param>
        protected abstract void PacketReceived(UDPPacketBuffer buffer);
+        
+        /// <summary>
+        /// This method is called when an outgoing packet is sent
+        /// </summary>
+        /// <param name="buffer">Outgoing packet buffer</param>
+        /// <param name="bytesSent">Number of bytes written to the wire</param>
        protected abstract void PacketSent(UDPPacketBuffer buffer, int bytesSent);
-        // the port to listen on
+        /// <summary>UDP port to bind to in server mode</summary>
-        internal int udpPort;
+        protected int m_udpPort;
-        // the UDP socket
+        /// <summary>Local IP address to bind to in server mode</summary>
-        private Socket udpSocket;
+        protected IPAddress m_localBindAddress;
-        // the all important shutdownFlag.
+        /// <summary>UDP socket, used in either client or server mode</summary>
-        private volatile bool shutdownFlag = true;
+        private Socket m_udpSocket;
-        // the remote endpoint to communicate with
+        /// <summary>The all important shutdown flag</summary>
-        protected IPEndPoint remoteEndPoint = null;
+        private volatile bool m_shutdownFlag = true;
-        /// <summary>
+        /// <summary>Returns true if the server is currently listening, otherwise false</summary>
-        /// Initialize the UDP packet handler in server mode
+        public bool IsRunning { get { return !m_shutdownFlag; } }
-        /// </summary>
-        /// <param name="port">Port to listening for incoming UDP packets on</param>
-        public OpenSimUDPBase(int port)
-        {
-            udpPort = port;
-        }
        /// <summary>
-        /// Initialize the UDP packet handler in client mode
+        /// Default constructor
        /// </summary>
-        /// <param name="endPoint">Remote UDP server to connect to</param>
+        /// <param name="bindAddress">Local IP address to bind the server to</param>
-        public OpenSimUDPBase(IPEndPoint endPoint)
+        /// <param name="port">Port to listening for incoming UDP packets on</param>
+        /// 
+        public OpenSimUDPBase(IPAddress bindAddress, int port)
        {
-            remoteEndPoint = endPoint;
+            m_localBindAddress = bindAddress;
-            udpPort = 0;
+            m_udpPort = port;
        }
        /// <summary>
-        /// 
+        /// Start the UDP server
        /// </summary>
-        public void Start()
+        /// <param name="recvBufferSize">The size of the receive buffer for 
+        /// the UDP socket. This value is passed up to the operating system 
+        /// and used in the system networking stack. Use zero to leave this
+        /// value as the default</param>
+        /// <remarks>This method will attempt to set the SIO_UDP_CONNRESET flag
+        /// on the socket to get newer versions of Windows to behave in a sane
+        /// manner (not throwing an exception when the remote side resets the
+        /// connection). This call is ignored on Mono where the flag is not
+        /// necessary</remarks>
+        public void Start(int recvBufferSize)
        {
-            if (shutdownFlag)
+            if (m_shutdownFlag)
            {
                const int SIO_UDP_CONNRESET = -1744830452;
-                IPEndPoint ipep = new IPEndPoint(Settings.BIND_ADDR, udpPort);
+                IPEndPoint ipep = new IPEndPoint(m_localBindAddress, m_udpPort);
-                udpSocket = new Socket(
+                m_udpSocket = new Socket(
                    AddressFamily.InterNetwork,
                    SocketType.Dgram,
                    ProtocolType.Udp);
                try
                {
-                    // this udp socket flag is not supported under mono, 
+                    // This udp socket flag is not supported under mono, 
                    // so we'll catch the exception and continue
-                    udpSocket.IOControl(SIO_UDP_CONNRESET, new byte[] { 0 }, null);
+                    m_udpSocket.IOControl(SIO_UDP_CONNRESET, new byte[] { 0 }, null);
+                    m_log.Debug("[UDPBASE]: SIO_UDP_CONNRESET flag set");
                }
                catch (SocketException)
                {
-                    Logger.DebugLog("UDP SIO_UDP_CONNRESET flag not supported on this platform");
+                    m_log.Debug("[UDPBASE]: SIO_UDP_CONNRESET flag not supported on this platform, ignoring");
                }
-                udpSocket.Bind(ipep);
+                if (recvBufferSize != 0)
+                    m_udpSocket.ReceiveBufferSize = recvBufferSize;
+                m_udpSocket.Bind(ipep);
                // we're not shutting down, we're starting up
-                shutdownFlag = false;
+                m_shutdownFlag = false;
                // kick off an async receive.  The Start() method will return, the
                // actual receives will occur asynchronously and will be caught in
@@ -423,41 +133,33 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        }
        /// <summary>
-        /// 
+        /// Stops the UDP server
        /// </summary>
        public void Stop()
        {
-            if (!shutdownFlag)
+            if (!m_shutdownFlag)
            {
                // wait indefinitely for a writer lock.  Once this is called, the .NET runtime
                // will deny any more reader locks, in effect blocking all other send/receive
                // threads.  Once we have the lock, we set shutdownFlag to inform the other
                // threads that the socket is closed.
-                shutdownFlag = true;
+                m_shutdownFlag = true;
-                udpSocket.Close();
+                m_udpSocket.Close();
            }
        }
-        /// <summary>
-        /// 
-        /// </summary>
-        public bool IsRunning
-        {
-            get { return !shutdownFlag; }
-        }
        private void AsyncBeginReceive()
        {
            // allocate a packet buffer
            //WrappedObject<UDPPacketBuffer> wrappedBuffer = Pool.CheckOut();
            UDPPacketBuffer buf = new UDPPacketBuffer();
-            if (!shutdownFlag)
+            if (!m_shutdownFlag)
            {
                try
                {
                    // kick off an async read
-                    udpSocket.BeginReceiveFrom(
+                    m_udpSocket.BeginReceiveFrom(
                        //wrappedBuffer.Instance.Data,
                        buf.Data,
                        0,
@@ -472,13 +174,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                {
                    if (e.SocketErrorCode == SocketError.ConnectionReset)
                    {
-                        Logger.Log("SIO_UDP_CONNRESET was ignored, attempting to salvage the UDP listener on port " + udpPort, Helpers.LogLevel.Error);
+                        m_log.Warn("[UDPBASE]: SIO_UDP_CONNRESET was ignored, attempting to salvage the UDP listener on port " + m_udpPort);
                        bool salvaged = false;
                        while (!salvaged)
                        {
                            try
                            {
-                                udpSocket.BeginReceiveFrom(
+                                m_udpSocket.BeginReceiveFrom(
                                    //wrappedBuffer.Instance.Data,
                                    buf.Data,
                                    0,
@@ -494,7 +196,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                            catch (ObjectDisposedException) { return; }
                        }
-                        Logger.Log("Salvaged the UDP listener on port " + udpPort, Helpers.LogLevel.Info);
+                        m_log.Warn("[UDPBASE]: Salvaged the UDP listener on port " + m_udpPort);
                    }
                }
                catch (ObjectDisposedException) { }
@@ -505,7 +207,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        {
            // Asynchronous receive operations will complete here through the call
            // to AsyncBeginReceive
-            if (!shutdownFlag)
+            if (!m_shutdownFlag)
            {
                // start another receive - this keeps the server going!
                AsyncBeginReceive();
@@ -520,7 +222,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                {
                    // get the length of data actually read from the socket, store it with the
                    // buffer
-                    buffer.DataLength = udpSocket.EndReceiveFrom(iar, ref buffer.RemoteEndPoint);
+                    buffer.DataLength = m_udpSocket.EndReceiveFrom(iar, ref buffer.RemoteEndPoint);
                    // call the abstract method PacketReceived(), passing the buffer that
                    // has just been filled from the socket read.
@@ -529,16 +231,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                catch (SocketException) { }
                catch (ObjectDisposedException) { }
                //finally { wrappedBuffer.Dispose(); }
            }
        }
        public void AsyncBeginSend(UDPPacketBuffer buf)
        {
-            if (!shutdownFlag)
+            if (!m_shutdownFlag)
            {
                try
                {
-                    udpSocket.BeginSendTo(
+                    m_udpSocket.BeginSendTo(
                        buf.Data,
                        0,
                        buf.DataLength,
@@ -557,7 +260,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            try
            {
                UDPPacketBuffer buf = (UDPPacketBuffer)result.AsyncState;
-                int bytesSent = udpSocket.EndSendTo(result);
+                int bytesSent = m_udpSocket.EndSendTo(result);
                PacketSent(buf, bytesSent);
            }
@@ -566,4 +269,3 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        }
    }
 }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs b/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs
index 858a03c..008d827 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs
@@ -26,6 +26,7 @@
 */
 using System;
+using OpenSim.Framework;
 using Nini.Config;
 namespace OpenSim.Region.ClientStack.LindenUDP
@@ -45,12 +46,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        public int Wind;
        /// <summary>Drip rate for cloud packets</summary>
        public int Cloud;
-        /// <summary>Drip rate for task (state and transaction) packets</summary>
+        /// <summary>Drip rate for task packets</summary>
        public int Task;
        /// <summary>Drip rate for texture packets</summary>
        public int Texture;
        /// <summary>Drip rate for asset packets</summary>
        public int Asset;
+        /// <summary>Drip rate for 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;
@@ -66,6 +71,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        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>
        /// Default constructor
@@ -77,23 +86,81 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            {
                IConfig throttleConfig = config.Configs["ClientStack.LindenUDP"];
-                Resend = throttleConfig.GetInt("ResendDefault", 12500);
+                Resend = throttleConfig.GetInt("resend_default", 12500);
-                Land = throttleConfig.GetInt("LandDefault", 500);
+                Land = throttleConfig.GetInt("land_default", 500);
-                Wind = throttleConfig.GetInt("WindDefault", 500);
+                Wind = throttleConfig.GetInt("wind_default", 500);
-                Cloud = throttleConfig.GetInt("CloudDefault", 500);
+                Cloud = throttleConfig.GetInt("cloud_default", 500);
-                Task = throttleConfig.GetInt("TaskDefault", 500);
+                Task = throttleConfig.GetInt("task_default", 500);
-                Texture = throttleConfig.GetInt("TextureDefault", 500);
+                Texture = throttleConfig.GetInt("texture_default", 500);
-                Asset = throttleConfig.GetInt("AssetDefault", 500);
+                Asset = throttleConfig.GetInt("asset_default", 500);
+                State = throttleConfig.GetInt("state_default", 500);
-                ResendLimit = throttleConfig.GetInt("ResendLimit", 18750);
+                Total = throttleConfig.GetInt("client_throttle_max_bps", 0);
-                LandLimit = throttleConfig.GetInt("LandLimit", 29750);
-                WindLimit = throttleConfig.GetInt("WindLimit", 18750);
+                ResendLimit = throttleConfig.GetInt("resend_limit", 18750);
-                CloudLimit = throttleConfig.GetInt("CloudLimit", 18750);
+                LandLimit = throttleConfig.GetInt("land_limit", 29750);
-                TaskLimit = throttleConfig.GetInt("TaskLimit", 55750);
+                WindLimit = throttleConfig.GetInt("wind_limit", 18750);
-                TextureLimit = throttleConfig.GetInt("TextureLimit", 55750);
+                CloudLimit = throttleConfig.GetInt("cloud_limit", 18750);
-                AssetLimit = throttleConfig.GetInt("AssetLimit", 27500);
+                TaskLimit = throttleConfig.GetInt("task_limit", 18750);
+                TextureLimit = throttleConfig.GetInt("texture_limit", 55750);
+                AssetLimit = throttleConfig.GetInt("asset_limit", 27500);
+                State = throttleConfig.GetInt("state_limit", 37000);
+                TotalLimit = throttleConfig.GetInt("client_throttle_max_bps", 0);
            }
            catch (Exception) { }
        }
+        public int GetRate(ThrottleOutPacketType type)
+        {
+            switch (type)
+            {
+                case ThrottleOutPacketType.Resend:
+                    return Resend;
+                case ThrottleOutPacketType.Land:
+                    return Land;
+                case ThrottleOutPacketType.Wind:
+                    return Wind;
+                case ThrottleOutPacketType.Cloud:
+                    return Cloud;
+                case ThrottleOutPacketType.Task:
+                    return Task;
+                case ThrottleOutPacketType.Texture:
+                    return Texture;
+                case ThrottleOutPacketType.Asset:
+                    return Asset;
+                case ThrottleOutPacketType.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/LindenUDP/UnackedPacketCollection.cs b/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
index 195ca57..f3242c1 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
@@ -103,6 +103,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        }
        /// <summary>
+        /// Removes all elements from the collection
+        /// </summary>
+        public void Clear()
+        {
+            lock (SyncRoot)
+                packets.Clear();
+        }
+        /// <summary>
        /// Gets the packet with the lowest sequence number
        /// </summary>
        /// <returns>The packet with the lowest sequence number, or null if the
diff --git a/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs b/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs
index f941728..7855862 100644
--- a/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs
@@ -36,6 +36,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
 {
    public class GodsModule : IRegionModule, IGodsModule
    {
+        /// <summary>Special UUID for actions that apply to all agents</summary>
+        private static readonly UUID ALL_AGENTS = new UUID("44e87126-e794-4ded-05b3-7c42da3d5cdb");
        protected Scene m_scene;
        protected IDialogModule m_dialogModule;
        
@@ -99,8 +102,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
        /// <param name="reason">The message to send to the user after it's been turned into a field</param>
        public void KickUser(UUID godID, UUID sessionID, UUID agentID, uint kickflags, byte[] reason)
        {
-            // For some reason the client sends this seemingly hard coded UUID for kicking everyone.   Dun-know.
+            UUID kickUserID = ALL_AGENTS;
-            UUID kickUserID = new UUID("44e87126e7944ded05b37c42da3d5cdb");
            
            ScenePresence sp = m_scene.GetScenePresence(agentID);
@@ -110,15 +112,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
                {
                    if (agentID == kickUserID)
                    {
-                        m_scene.ClientManager.ForEachClient(
+                        string reasonStr = Utils.BytesToString(reason);
+                        m_scene.ClientManager.ForEach(
                            delegate(IClientAPI controller)
                            {
                                if (controller.AgentId != godID)
-                                    controller.Kick(Utils.BytesToString(reason));
+                                    controller.Kick(reasonStr);
                            }
                        );
-                        // This is a bit crude.   It seems the client will be null before it actually stops the thread
+                        // This is a bit crude. It seems the client will be null before it actually stops the thread
                        // The thread will kill itself eventually :/
                        // Is there another way to make sure *all* clients get this 'inter region' message?
                        m_scene.ForEachScenePresence(
@@ -128,7 +132,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
                                {
                                    // Possibly this should really be p.Close() though that method doesn't send a close
                                    // to the client
-                                    p.ControllingClient.Close(true);
+                                    p.ControllingClient.Close();
                                }
                            }
                        );
@@ -138,7 +142,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
                        m_scene.SceneGraph.removeUserCount(!sp.IsChildAgent);
                        sp.ControllingClient.Kick(Utils.BytesToString(reason));
-                        sp.ControllingClient.Close(true);
+                        sp.ControllingClient.Close();
                    }
                }
                else
diff --git a/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs b/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs
index 7d6f150..d636b1c 100644
--- a/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs
+++ b/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs
@@ -1267,7 +1267,7 @@ namespace OpenSim.Region.CoreModules.InterGrid
                if (avToBeKilled.IsChildAgent)
                {
                    m_mod.DeleteOGPState(avUUID);
-                    avToBeKilled.ControllingClient.Close(true);
+                    avToBeKilled.ControllingClient.Close();
                }
            }
        }
diff --git a/OpenSim/Region/CoreModules/Scripting/LSLHttp/UrlModule.cs b/OpenSim/Region/CoreModules/Scripting/LSLHttp/UrlModule.cs
index b885420..9b565ed 100644
--- a/OpenSim/Region/CoreModules/Scripting/LSLHttp/UrlModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/LSLHttp/UrlModule.cs
@@ -57,7 +57,7 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
        public string body;
        public int responseCode;
        public string responseBody;
-        public ManualResetEvent ev;
+        //public ManualResetEvent ev;
        public bool requestDone;
        public int startTime;
        public string uri;
@@ -456,7 +456,7 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                    requestData.headers["x-query-string"] = queryString;
                    requestData.headers["x-script-url"] = url.url;
-                    requestData.ev = new ManualResetEvent(false);
+                    //requestData.ev = new ManualResetEvent(false);
                    lock (url.requests)
                    {
                        url.requests.Add(requestID, requestData);
diff --git a/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs b/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
index 8ad4844..d651fd4 100644
--- a/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
+++ b/OpenSim/Region/Examples/SimpleModule/MyNpcCharacter.cs
@@ -813,7 +813,7 @@ namespace OpenSim.Region.Examples.SimpleModule
        {
        }
-        public void Close(bool ShutdownCircuit)
+        public void Close()
        {
        }
@@ -833,6 +833,11 @@ namespace OpenSim.Region.Examples.SimpleModule
            set { m_circuitCode = value; }
        }
+        public IPEndPoint RemoteEndPoint
+        {
+            get { return new IPEndPoint(IPAddress.Loopback, (ushort)m_circuitCode); }
+        }
        public void SendBlueBoxMessage(UUID FromAvatarID, String FromAvatarName, String Message)
        {
diff --git a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
index 4ae4dc3..ac89f7b 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
@@ -390,6 +390,32 @@ namespace OpenSim.Region.Framework.Scenes
                EventManager.TriggerScriptReset(part.LocalId, itemID);
            }
        }
+        void ProcessViewerEffect(IClientAPI remoteClient, List<ViewerEffectEventHandlerArg> args)
+        {
+            // TODO: don't create new blocks if recycling an old packet
+            List<ViewerEffectPacket.EffectBlock> effectBlock = new List<ViewerEffectPacket.EffectBlock>();
+            for (int i = 0; i < args.Count; i++)
+            {
+                ViewerEffectPacket.EffectBlock effect = new ViewerEffectPacket.EffectBlock();
+                effect.AgentID = args[i].AgentID;
+                effect.Color = args[i].Color;
+                effect.Duration = args[i].Duration;
+                effect.ID = args[i].ID;
+                effect.Type = args[i].Type;
+                effect.TypeData = args[i].TypeData;
+                effectBlock.Add(effect);
+            }
+            ViewerEffectPacket.EffectBlock[] effectBlockArray = effectBlock.ToArray();
+            ClientManager.ForEach(
+                delegate(IClientAPI client)
+                {
+                    if (client.AgentId != remoteClient.AgentId)
+                        client.SendViewerEffect(effectBlockArray);
+                }
+            );
+        }
        
        /// <summary>
        /// Handle a fetch inventory request from the client
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 04eb93f..14e4534 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -117,6 +117,8 @@ namespace OpenSim.Region.Framework.Scenes
        private volatile bool m_backingup = false;
        private Dictionary<UUID, ReturnInfo> m_returns = new Dictionary<UUID, ReturnInfo>();
+        
+        private Dictionary<UUID, SceneObjectGroup> m_groupsWithTargets = new Dictionary<UUID, SceneObjectGroup>();
        protected string m_simulatorVersion = "OpenSimulator Server";
@@ -246,8 +248,7 @@ namespace OpenSim.Region.Framework.Scenes
        private int m_update_physics = 1;
        private int m_update_entitymovement = 1;
-        private int m_update_entities = 1; // Run through all objects checking for updates
+        private int m_update_objects = 1; // Update objects which have scheduled themselves for updates
-        private int m_update_entitiesquick = 200; // Run through objects that have scheduled updates checking for updates
        private int m_update_presences = 1; // Update scene presence movements
        private int m_update_events = 1;
        private int m_update_backup = 200;
@@ -867,7 +868,7 @@ namespace OpenSim.Region.Framework.Scenes
            Thread.Sleep(500);
            // Stop all client threads.
-            ForEachScenePresence(delegate(ScenePresence avatar) { avatar.ControllingClient.Close(true); });
+            ForEachScenePresence(delegate(ScenePresence avatar) { avatar.ControllingClient.Close(); });
            // Stop updating the scene objects and agents.
            //m_heartbeatTimer.Close();
@@ -979,28 +980,7 @@ namespace OpenSim.Region.Framework.Scenes
                maintc = Environment.TickCount;
                TimeSpan SinceLastFrame = DateTime.Now - m_lastupdate;
-                // Aquire a lock so only one update call happens at once
-                //updateLock.WaitOne();
                float physicsFPS = 0;
-                //m_log.Info("sadfadf" + m_neighbours.Count.ToString());
-                int agentsInScene = m_sceneGraph.GetRootAgentCount() + m_sceneGraph.GetChildAgentCount();
-                if (agentsInScene > 21)
-                {
-                    if (m_update_entities == 1)
-                    {
-                        m_update_entities = 5;
-                        StatsReporter.SetUpdateMS(6000);
-                    }
-                }
-                else
-                {
-                    if (m_update_entities == 5)
-                    {
-                        m_update_entities = 1;
-                        StatsReporter.SetUpdateMS(3000);
-                    }
-                }
                frameMS = Environment.TickCount;
                try
@@ -1013,30 +993,17 @@ namespace OpenSim.Region.Framework.Scenes
                        m_frame = 0;
                    otherMS = Environment.TickCount;
-                    // run through all entities looking for updates (slow)
-                    if (m_frame % m_update_entities == 0)
-                    {
-                        /* // Adam Experimental
-                        if (m_updateEntitiesThread == null)
-                        {
-                            m_updateEntitiesThread = new Thread(m_sceneGraph.UpdateEntities);
-                            ThreadTracker.Add(m_updateEntitiesThread);
-                        }
-                        if (m_updateEntitiesThread.ThreadState == ThreadState.Stopped)
-                            m_updateEntitiesThread.Start();
-                        */
-                        m_sceneGraph.UpdateEntities();
+                    // Check if any objects have reached their targets
-                    }
+                    CheckAtTargets();
+ 
+                    // Update SceneObjectGroups that have scheduled themselves for updates
+                    // Objects queue their updates onto all scene presences
+                    if (m_frame % m_update_objects == 0)
+                        m_sceneGraph.UpdateObjectGroups();
-                    // run through entities that have scheduled themselves for
+                    // Run through all ScenePresences looking for updates
-                    // updates looking for updates(faster)
+                    // Presence updates and queued object updates for each presence are sent to clients
-                    if (m_frame % m_update_entitiesquick == 0)
-                        m_sceneGraph.ProcessUpdates();
-                    // Run through scenepresences looking for updates
                    if (m_frame % m_update_presences == 0)
                        m_sceneGraph.UpdatePresences();
@@ -1140,6 +1107,31 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
+        public void AddGroupTarget(SceneObjectGroup grp)
+        {
+            lock(m_groupsWithTargets)
+                m_groupsWithTargets[grp.UUID] = grp;
+        }
+        public void RemoveGroupTarget(SceneObjectGroup grp)
+        {
+            lock(m_groupsWithTargets)
+                m_groupsWithTargets.Remove(grp.UUID);
+        }
+        private void CheckAtTargets()
+        {
+            lock (m_groupsWithTargets)
+            {
+                foreach (KeyValuePair<UUID, SceneObjectGroup> kvp in m_groupsWithTargets)
+                {
+                    kvp.Value.checkAtTargets();
+                }
+            }
+        }
        /// <summary>
        /// Send out simstats data to all clients
        /// </summary>
@@ -1186,10 +1178,10 @@ namespace OpenSim.Region.Framework.Scenes
            if (!m_backingup)
            {
                m_backingup = true;
-                Thread backupthread = new Thread(Backup);
-                backupthread.Name = "BackupWriter";
+                System.ComponentModel.BackgroundWorker backupWorker = new System.ComponentModel.BackgroundWorker();
-                backupthread.IsBackground = true;
+                backupWorker.DoWork += delegate(object sender, System.ComponentModel.DoWorkEventArgs e) { Backup(); };
-                backupthread.Start();
+                backupWorker.RunWorkerAsync();
            }
        }
@@ -2436,6 +2428,8 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="client"></param>
        public override void AddNewClient(IClientAPI client)
        {
+            ClientManager.Add(client);
            CheckHeartbeat();
            SubscribeToClientEvents(client);
            ScenePresence presence;
@@ -2645,6 +2639,7 @@ namespace OpenSim.Region.Framework.Scenes
        public virtual void SubscribeToClientNetworkEvents(IClientAPI client)
        {
            client.OnNetworkStatsUpdate += StatsReporter.AddPacketsStats;
+            client.OnViewerEffect += ProcessViewerEffect;
        }
        protected virtual void UnsubscribeToClientEvents(IClientAPI client)
@@ -2799,11 +2794,9 @@ namespace OpenSim.Region.Framework.Scenes
        public virtual void UnSubscribeToClientNetworkEvents(IClientAPI client)
        {
            client.OnNetworkStatsUpdate -= StatsReporter.AddPacketsStats;
+            client.OnViewerEffect -= ProcessViewerEffect;
        }
-        
        /// <summary>
        /// Teleport an avatar to their home region
        /// </summary>
@@ -3076,7 +3069,9 @@ namespace OpenSim.Region.Framework.Scenes
                    agentTransactions.RemoveAgentAssetTransactions(agentID);
                }
+                // Remove the avatar from the scene
                m_sceneGraph.RemoveScenePresence(agentID);
+                ClientManager.Remove(agentID);
                try
                {
@@ -3126,16 +3121,6 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// Closes all endpoints with the circuitcode provided.
-        /// </summary>
-        /// <param name="circuitcode">Circuit Code of the endpoint to close</param>
-        public override void CloseAllAgents(uint circuitcode)
-        {
-            // Called by ClientView to kill all circuit codes
-            ClientManager.CloseAllAgents(circuitcode);
-        }
-        /// <summary>
        /// Inform all other ScenePresences on this Scene that someone else has changed position on the minimap.
        /// </summary>
        public void NotifyMyCoarseLocationChange()
@@ -3456,7 +3441,7 @@ namespace OpenSim.Region.Framework.Scenes
                    loggingOffUser.ControllingClient.Kick(message);
                    // Give them a second to receive the message!
                    Thread.Sleep(1000);
-                    loggingOffUser.ControllingClient.Close(true);
+                    loggingOffUser.ControllingClient.Close();
                }
                else
                {
@@ -3627,7 +3612,7 @@ namespace OpenSim.Region.Framework.Scenes
                        presence.ControllingClient.SendShutdownConnectionNotice();
                }
-                presence.ControllingClient.Close(true);
+                presence.ControllingClient.Close();
                return true;
            }
diff --git a/OpenSim/Region/Framework/Scenes/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
index 0ac4ed4..cf5c3c8 100644
--- a/OpenSim/Region/Framework/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -196,8 +196,6 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="agentID"></param>
        public abstract void RemoveClient(UUID agentID);
-        public abstract void CloseAllAgents(uint circuitcode);
        #endregion
        /// <summary>
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index 54ac792..9cd2247 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -77,7 +77,7 @@ namespace OpenSim.Region.Framework.Scenes
        protected RegionInfo m_regInfo;
        protected Scene m_parentScene;
-        protected Dictionary<UUID, EntityBase> m_updateList = new Dictionary<UUID, EntityBase>();
+        protected Dictionary<UUID, SceneObjectGroup> m_updateList = new Dictionary<UUID, SceneObjectGroup>();
        protected int m_numRootAgents = 0;
        protected int m_numPrim = 0;
        protected int m_numChildAgents = 0;
@@ -155,16 +155,6 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
-        protected internal void UpdateEntities()
-        {
-            List<EntityBase> updateEntities = GetEntities();
-            foreach (EntityBase entity in updateEntities)
-            {
-                entity.Update();
-            }
-        }
        protected internal void UpdatePresences()
        {
            List<ScenePresence> updateScenePresences = GetScenePresences();
@@ -365,12 +355,12 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// Add an entity to the list of prims to process on the next update
+        /// Add an object to the list of prims to process on the next update
        /// </summary>
        /// <param name="obj">
-        /// A <see cref="EntityBase"/>
+        /// A <see cref="SceneObjectGroup"/>
        /// </param>
-        protected internal void AddToUpdateList(EntityBase obj)
+        protected internal void AddToUpdateList(SceneObjectGroup obj)
        {
            lock (m_updateList)
            {
@@ -381,18 +371,18 @@ namespace OpenSim.Region.Framework.Scenes
        /// <summary>
        /// Process all pending updates
        /// </summary>
-        protected internal void ProcessUpdates()
+        protected internal void UpdateObjectGroups()
        {
-            Dictionary<UUID, EntityBase> updates;
+            Dictionary<UUID, SceneObjectGroup> updates;
            // Some updates add more updates to the updateList. 
            // Get the current list of updates and clear the list before iterating
            lock (m_updateList)
            {
-                updates = new Dictionary<UUID, EntityBase>(m_updateList);
+                updates = new Dictionary<UUID, SceneObjectGroup>(m_updateList);
                m_updateList.Clear();
            }
-            // Go through all timers
+            // Go through all updates
-            foreach (KeyValuePair<UUID, EntityBase> kvp in updates)
+            foreach (KeyValuePair<UUID, SceneObjectGroup> kvp in updates)
            {
                // Don't abort the whole update if one entity happens to give us an exception.
                try
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 6a10618..d4cef7d 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -1234,6 +1234,7 @@ namespace OpenSim.Region.Framework.Scenes
            {
                lock (m_targets)
                    m_targets.Clear();
+                m_scene.RemoveGroupTarget(this);
            }
            ScheduleGroupForFullUpdate();
@@ -1864,12 +1865,6 @@ namespace OpenSim.Region.Framework.Scenes
                    m_rootPart.UpdateFlag = 1;
                    lastPhysGroupPos = AbsolutePosition;
                }
-                //foreach (SceneObjectPart part in m_parts.Values)
-                    //{
-                        //if (part.UpdateFlag == 0) part.UpdateFlag = 1;
-                    //}
-                checkAtTargets();
                if (UsePhysics && ((Math.Abs(lastPhysGroupRot.W - GroupRotation.W) > 0.1)
                    || (Math.Abs(lastPhysGroupRot.X - GroupRotation.X) > 0.1)
@@ -3114,6 +3109,7 @@ namespace OpenSim.Region.Framework.Scenes
            {
                m_targets.Add(handle, waypoint);
            }
+            m_scene.AddGroupTarget(this);
            return (int)handle;
        }
        
@@ -3121,12 +3117,13 @@ namespace OpenSim.Region.Framework.Scenes
        {
            lock (m_targets)
            {
-                if (m_targets.ContainsKey((uint)handle))
+                m_targets.Remove((uint)handle);
-                    m_targets.Remove((uint)handle);
+                if (m_targets.Count == 0)
+                    m_scene.RemoveGroupTarget(this);
            }
        }
-        private void checkAtTargets()
+        public void checkAtTargets()
        {
            if (m_scriptListens_atTarget || m_scriptListens_notAtTarget)
            {
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneBaseTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneBaseTests.cs
index 5c9e66f..8230f32 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneBaseTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneBaseTests.cs
@@ -61,11 +61,6 @@ namespace OpenSim.Region.Framework.Scenes.Tests
                throw new NotImplementedException();
            }
-            public override void CloseAllAgents(uint circuitcode)
-            {
-                throw new NotImplementedException();
-            }
            public override void OtherRegionUp(GridRegion otherRegion)
            {
                throw new NotImplementedException();
diff --git a/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/IRCStackModule.cs b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/IRCStackModule.cs
index 4b199ac..4c2a4b9 100644
--- a/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/IRCStackModule.cs
+++ b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/IRCStackModule.cs
@@ -64,7 +64,6 @@ namespace OpenSim.Region.OptionalModules.Agent.InternetRelayClientView
        void user_OnIRCReady(IRCClientView cv)
        {
            m_log.Info("[IRCd] Adding user...");
-            m_scene.ClientManager.Add(cv.CircuitCode, cv);
            cv.Start();
            m_log.Info("[IRCd] Added user to Scene");
        }
diff --git a/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
index 4364627..a8acf0d 100644
--- a/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
+++ b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
@@ -634,6 +634,12 @@ namespace OpenSim.Region.OptionalModules.Agent.InternetRelayClientView.Server
        {
            get { return (uint)Util.RandomClass.Next(0,int.MaxValue); }
        }
+        public IPEndPoint RemoteEndPoint
+        {
+            get { return (IPEndPoint)m_client.Client.RemoteEndPoint; }
+        }
 #pragma warning disable 67
        public event GenericMessage OnGenericMessage;
        public event ImprovedInstantMessage OnInstantMessage;
@@ -843,7 +849,7 @@ namespace OpenSim.Region.OptionalModules.Agent.InternetRelayClientView.Server
            
        }
-        public void Close(bool ShutdownCircuit)
+        public void Close()
        {
            Disconnect();
        }
diff --git a/OpenSim/Region/OptionalModules/ContentManagementSystem/MetaEntity.cs b/OpenSim/Region/OptionalModules/ContentManagementSystem/MetaEntity.cs
index d6dacbc..b6513e2 100644
--- a/OpenSim/Region/OptionalModules/ContentManagementSystem/MetaEntity.cs
+++ b/OpenSim/Region/OptionalModules/ContentManagementSystem/MetaEntity.cs
@@ -183,8 +183,9 @@ namespace OpenSim.Region.OptionalModules.ContentManagement
        public virtual void HideFromAll()
        {
            foreach (SceneObjectPart part in m_Entity.Children.Values)
-                m_Entity.Scene.ClientManager.ForEachClient(delegate(IClientAPI controller)
+                m_Entity.Scene.ClientManager.ForEach(
-                                                           { controller.SendKillObject(m_Entity.RegionHandle, part.LocalId); }
+                    delegate(IClientAPI controller)
+                    { controller.SendKillObject(m_Entity.RegionHandle, part.LocalId); }
                );
        }
@@ -201,8 +202,9 @@ namespace OpenSim.Region.OptionalModules.ContentManagement
        public void SendFullUpdateToAll()
        {
-            m_Entity.Scene.ClientManager.ForEachClient(delegate(IClientAPI controller)
+            m_Entity.Scene.ClientManager.ForEach(
-                                                       { m_Entity.SendFullUpdateToClient(controller); }
+                delegate(IClientAPI controller)
+                { m_Entity.SendFullUpdateToClient(controller); }
            );
        }
diff --git a/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs b/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs
index ac8b98c..f7c63ac 100644
--- a/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs
+++ b/OpenSim/Region/OptionalModules/World/NPC/NPCAvatar.cs
@@ -825,7 +825,7 @@ namespace OpenSim.Region.OptionalModules.World.NPC
        {
        }
-        public void Close(bool ShutdownCircuit)
+        public void Close()
        {
        }
@@ -838,11 +838,21 @@ namespace OpenSim.Region.OptionalModules.World.NPC
        }
        private uint m_circuitCode;
+        private IPEndPoint m_remoteEndPoint;
        public uint CircuitCode
        {
            get { return m_circuitCode; }
-            set { m_circuitCode = value; }
+            set
+            {
+                m_circuitCode = value;
+                m_remoteEndPoint = new IPEndPoint(IPAddress.Loopback, (ushort)m_circuitCode);
+            }
+        }
+        public IPEndPoint RemoteEndPoint
+        {
+            get { return m_remoteEndPoint; }
        }
        public void SendBlueBoxMessage(UUID FromAvatarID, String FromAvatarName, String Message)
diff --git a/OpenSim/Region/OptionalModules/World/NPC/NPCModule.cs b/OpenSim/Region/OptionalModules/World/NPC/NPCModule.cs
index 30a2675..41a6255 100644
--- a/OpenSim/Region/OptionalModules/World/NPC/NPCModule.cs
+++ b/OpenSim/Region/OptionalModules/World/NPC/NPCModule.cs
@@ -155,7 +155,6 @@ namespace OpenSim.Region.OptionalModules.World.NPC
                    NPCAvatar npcAvatar = new NPCAvatar(p_firstname, p_lastname, p_position, p_scene);
                    npcAvatar.CircuitCode = (uint) Util.RandomClass.Next(0, int.MaxValue);
-                    p_scene.ClientManager.Add(npcAvatar.CircuitCode, npcAvatar);
                    p_scene.AddNewClient(npcAvatar);
                    ScenePresence sp;
diff --git a/OpenSim/Region/Physics/Meshing/PrimMesher.cs b/OpenSim/Region/Physics/Meshing/PrimMesher.cs
index a283840..47ce615 100644
--- a/OpenSim/Region/Physics/Meshing/PrimMesher.cs
+++ b/OpenSim/Region/Physics/Meshing/PrimMesher.cs
@@ -69,7 +69,7 @@ namespace PrimMesher
        public Quat Identity()
        {
-            return new Quat(0.0f, 0.0f, 0.0f, 1.1f);
+            return new Quat(0.0f, 0.0f, 0.0f, 1.0f);
        }
        public float Length()
diff --git a/OpenSim/Services/AssetService/AssetService.cs b/OpenSim/Services/AssetService/AssetService.cs
index ebfd47a..df33db2 100644
--- a/OpenSim/Services/AssetService/AssetService.cs
+++ b/OpenSim/Services/AssetService/AssetService.cs
@@ -64,12 +64,17 @@ namespace OpenSim.Services.AssetService
                string loaderArgs = assetConfig.GetString("AssetLoaderArgs",
                        String.Empty);
-                m_log.InfoFormat("[ASSET]: Loading default asset set from {0}", loaderArgs);
+                bool assetLoaderEnabled = assetConfig.GetBoolean("AssetLoaderEnabled", true);
-                m_AssetLoader.ForEachDefaultXmlAsset(loaderArgs,
-                        delegate(AssetBase a)
+                if (assetLoaderEnabled)
-                        {
+                {
-                            Store(a);
+                    m_log.InfoFormat("[ASSET]: Loading default asset set from {0}", loaderArgs);
-                        });
+                    m_AssetLoader.ForEachDefaultXmlAsset(loaderArgs,
+                            delegate(AssetBase a)
+                            {
+                                Store(a);
+                            });
+                }
                
                m_log.Info("[ASSET CONNECTOR]: Local asset service enabled");
            }
diff --git a/OpenSim/Tests/Common/Mock/TestClient.cs b/OpenSim/Tests/Common/Mock/TestClient.cs
index 2b54890..5c838c5 100644
--- a/OpenSim/Tests/Common/Mock/TestClient.cs
+++ b/OpenSim/Tests/Common/Mock/TestClient.cs
@@ -393,6 +393,11 @@ namespace OpenSim.Tests.Common.Mock
            set { m_circuitCode = value; }
        }
+        public IPEndPoint RemoteEndPoint
+        {
+            get { return new IPEndPoint(IPAddress.Loopback, (ushort)m_circuitCode); }
+        }
        /// <summary>
        /// Constructor
        /// </summary>
@@ -865,7 +870,7 @@ namespace OpenSim.Tests.Common.Mock
        {
        }
-        public void Close(bool ShutdownCircuit)
+        public void Close()
        {
            m_scene.RemoveClient(AgentId);
        }