1 files changed, 263 insertions, 158 deletions

diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
index 545a0bc..a9f4b2c 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
@@ -39,6 +39,8 @@ using OpenSim.Framework.Statistics;
 using OpenSim.Region.Framework.Scenes;
 using OpenMetaverse;
 
+using TokenBucket = OpenSim.Region.ClientStack.LindenUDP.TokenBucket;
+
 namespace OpenSim.Region.ClientStack.LindenUDP
 {
     /// <summary>
@@ -89,8 +91,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     /// </summary>
     public class LLUDPServer : OpenSimUDPBase
     {
+        /// <summary>Maximum transmission unit, or UDP packet size, for the LLUDP protocol</summary>
+        public const int MTU = 1400;
+
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        /// <summary>The measured resolution of Environment.TickCount</summary>
+        public readonly float TickCountResolution;
+
         /// <summary>Handlers for incoming packets</summary>
         //PacketEventDictionary packetEvents = new PacketEventDictionary();
         /// <summary>Incoming packets that are awaiting handling</summary>
@@ -104,20 +112,35 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>Manages authentication for agent circuits</summary>
         private AgentCircuitManager m_circuitManager;
         /// <summary>Reference to the scene this UDP server is attached to</summary>
-        private IScene m_scene;
+        private Scene m_scene;
         /// <summary>The X/Y coordinates of the scene this UDP server is attached to</summary>
         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>Flag to process packets asynchronously or synchronously</summary>
         private bool m_asyncPacketHandling;
+        /// <summary>Tracks whether or not a packet was sent each round so we know
+        /// whether or not to sleep</summary>
+        private bool m_packetSent;
+
+        /// <summary>Environment.TickCount of the last time the outgoing packet handler executed</summary>
+        private int m_tickLastOutgoingPacketHandler;
+        /// <summary>Keeps track of the number of elapsed milliseconds since the last time the outgoing packet handler looped</summary>
+        private int m_elapsedMSOutgoingPacketHandler;
+        /// <summary>Keeps track of the number of 100 millisecond periods elapsed in the outgoing packet handler executed</summary>
+        private int m_elapsed100MSOutgoingPacketHandler;
+        /// <summary>Keeps track of the number of 500 millisecond periods elapsed in the outgoing packet handler executed</summary>
+        private int m_elapsed500MSOutgoingPacketHandler;
+
+        /// <summary>Flag to signal when clients should check for resends</summary>
+        private bool m_resendUnacked;
+        /// <summary>Flag to signal when clients should send ACKs</summary>
+        private bool m_sendAcks;
+        /// <summary>Flag to signal when clients should send pings</summary>
+        private bool m_sendPing;
 
-        /// <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)
@@ -126,16 +149,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             #region Environment.TickCount Measurement
 
             // Measure the resolution of Environment.TickCount
-            m_tickCountResolution = 0f;
+            TickCountResolution = 0f;
             for (int i = 0; i < 5; i++)
             {
                 int start = Environment.TickCount;
                 int now = start;
                 while (now == start)
                     now = Environment.TickCount;
-                m_tickCountResolution += (float)(now - start) * 0.2f;
+                TickCountResolution += (float)(now - start) * 0.2f;
             }
             m_log.Info("[LLUDPSERVER]: Average Environment.TickCount resolution: " + TickCountResolution + "ms");
+            TickCountResolution = (float)Math.Ceiling(TickCountResolution);
 
             #endregion Environment.TickCount Measurement
 
@@ -181,15 +205,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void AddScene(IScene scene)
         {
-            if (m_scene == null)
+            if (m_scene != null)
             {
-                m_scene = scene;
-                m_location = new Location(m_scene.RegionInfo.RegionHandle);
+                m_log.Error("[LLUDPSERVER]: AddScene() called on an LLUDPServer that already has a scene");
+                return;
             }
-            else
+
+            if (!(scene is Scene))
             {
-                m_log.Error("[LLUDPSERVER]: AddScene() called on an LLUDPServer that already has a scene");
+                m_log.Error("[LLUDPSERVER]: AddScene() called with an unrecognized scene type " + scene.GetType());
+                return;
             }
+
+            m_scene = (Scene)scene;
+            m_location = new Location(m_scene.RegionInfo.RegionHandle);
         }
 
         public bool HandlesRegion(Location x)
@@ -267,38 +296,54 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             int dataLength = data.Length;
             bool doZerocode = (data[0] & Helpers.MSG_ZEROCODED) != 0;
+            bool doCopy = true;
 
             // Frequency analysis of outgoing packet sizes shows a large clump of packets at each end of the spectrum.
             // The vast majority of packets are less than 200 bytes, although due to asset transfers and packet splitting
             // there are a decent number of packets in the 1000-1140 byte range. We allocate one of two sizes of data here
             // to accomodate for both common scenarios and provide ample room for ACK appending in both
-            int bufferSize = (dataLength > 180) ? Packet.MTU : 200;
+            int bufferSize = (dataLength > 180) ? LLUDPServer.MTU : 200;
 
             UDPPacketBuffer buffer = new UDPPacketBuffer(udpClient.RemoteEndPoint, bufferSize);
 
             // Zerocode if needed
             if (doZerocode)
             {
-                try { dataLength = Helpers.ZeroEncode(data, dataLength, buffer.Data); }
+                try
+                {
+                    dataLength = Helpers.ZeroEncode(data, dataLength, buffer.Data);
+                    doCopy = false;
+                }
                 catch (IndexOutOfRangeException)
                 {
                     // The packet grew larger than the bufferSize while zerocoding.
                     // Remove the MSG_ZEROCODED flag and send the unencoded data
                     // instead
-                    m_log.Debug("[LLUDPSERVER]: Packet exceeded buffer size during zerocoding for " + type + ". Removing MSG_ZEROCODED flag");
+                    m_log.Debug("[LLUDPSERVER]: Packet exceeded buffer size during zerocoding for " + type + ". DataLength=" + dataLength +
+                        " and BufferLength=" + buffer.Data.Length + ". Removing MSG_ZEROCODED flag");
                     data[0] = (byte)(data[0] & ~Helpers.MSG_ZEROCODED);
-                    Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
                 }
             }
-            else
+
+            // If the packet data wasn't already copied during zerocoding, copy it now
+            if (doCopy)
             {
-                Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
+                if (dataLength <= buffer.Data.Length)
+                {
+                    Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
+                }
+                else
+                {
+                    m_log.Error("[LLUDPSERVER]: Packet exceeded buffer size! This could be an indication of packet assembly not obeying the MTU. Type=" +
+                        type + ", DataLength=" + dataLength + ", BufferLength=" + buffer.Data.Length + ". Dropping packet");
+                    return;
+                }
             }
+
             buffer.DataLength = dataLength;
 
             #region Queue or Send
 
-            // Look up the UDPClient this is going to
             OutgoingPacket outgoingPacket = new OutgoingPacket(udpClient, buffer, category);
 
             if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
@@ -338,57 +383,54 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             StartPingCheckPacket pc = (StartPingCheckPacket)PacketPool.Instance.GetPacket(PacketType.StartPingCheck);
             pc.Header.Reliable = false;
 
-            OutgoingPacket oldestPacket = udpClient.NeedAcks.GetOldest();
-
             pc.PingID.PingID = (byte)udpClient.CurrentPingSequence++;
-            pc.PingID.OldestUnacked = (oldestPacket != null) ? oldestPacket.SequenceNumber : 0;
+            // We *could* get OldestUnacked, but it would hurt performance and not provide any benefit
+            pc.PingID.OldestUnacked = 0;
 
             SendPacket(udpClient, pc, ThrottleOutPacketType.Unknown, false);
         }
 
         public void ResendUnacked(LLUDPClient udpClient)
         {
-            if (udpClient.IsConnected && udpClient.NeedAcks.Count > 0)
+            if (!udpClient.IsConnected)
+                return;
+
+            // Disconnect an agent if no packets are received for some time
+            //FIXME: Make 60 an .ini setting
+            if ((Environment.TickCount & Int32.MaxValue) - udpClient.TickLastPacketReceived > 1000 * 60)
             {
-                // 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);
+                m_log.Warn("[LLUDPSERVER]: Ack timeout, disconnecting " + udpClient.AgentID);
 
-                    RemoveClient(udpClient);
-                    return;
-                }
+                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);
+            // 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)
-                {
-                    // Resend packets
-                    for (int i = 0; i < expiredPackets.Count; i++)
-                    {
-                        OutgoingPacket outgoingPacket = expiredPackets[i];
+            if (expiredPackets != null)
+            {
+                m_log.Debug("[LLUDPSERVER]: Resending " + expiredPackets.Count + " packets to " + udpClient.AgentID + ", RTO=" + udpClient.RTO);
 
-                        //m_log.DebugFormat("[LLUDPSERVER]: Resending packet #{0} (attempt {1}), {2}ms have passed",
-                        //    outgoingPacket.SequenceNumber, outgoingPacket.ResendCount, Environment.TickCount - outgoingPacket.TickCount);
+                // Resend packets
+                for (int i = 0; i < expiredPackets.Count; i++)
+                {
+                    OutgoingPacket outgoingPacket = expiredPackets[i];
 
-                        // Set the resent flag
-                        outgoingPacket.Buffer.Data[0] = (byte)(outgoingPacket.Buffer.Data[0] | Helpers.MSG_RESENT);
-                        outgoingPacket.Category = ThrottleOutPacketType.Resend;
+                    //m_log.DebugFormat("[LLUDPSERVER]: Resending packet #{0} (attempt {1}), {2}ms have passed",
+                    //    outgoingPacket.SequenceNumber, outgoingPacket.ResendCount, Environment.TickCount - outgoingPacket.TickCount);
 
-                        // The TickCount will be set to the current time when the packet
-                        // is actually sent out again
-                        outgoingPacket.TickCount = 0;
+                    // Set the resent flag
+                    outgoingPacket.Buffer.Data[0] = (byte)(outgoingPacket.Buffer.Data[0] | Helpers.MSG_RESENT);
+                    outgoingPacket.Category = ThrottleOutPacketType.Resend;
 
-                        // Bump up the resend count on this packet
-                        Interlocked.Increment(ref outgoingPacket.ResendCount);
-                        //Interlocked.Increment(ref Stats.ResentPackets);
+                    // Bump up the resend count on this packet
+                    Interlocked.Increment(ref outgoingPacket.ResendCount);
+                    //Interlocked.Increment(ref Stats.ResentPackets);
 
-                        // Requeue or resend the packet
-                        if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
-                            SendPacketFinal(outgoingPacket);
-                    }
+                    // Requeue or resend the packet
+                    if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
+                        SendPacketFinal(outgoingPacket);
                 }
             }
         }
@@ -409,9 +451,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (!udpClient.IsConnected)
                 return;
 
-            // Keep track of when this packet was sent out (right now)
-            outgoingPacket.TickCount = Environment.TickCount;
-
             #region ACK Appending
 
             int dataLength = buffer.DataLength;
@@ -464,6 +503,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             // Put the UDP payload on the wire
             AsyncBeginSend(buffer);
+
+            // Keep track of when this packet was sent out (right now)
+            outgoingPacket.TickCount = Environment.TickCount & Int32.MaxValue;
         }
 
         protected override void PacketReceived(UDPPacketBuffer buffer)
@@ -506,14 +548,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // UseCircuitCode handling
             if (packet.Type == PacketType.UseCircuitCode)
             {
-                AddNewClient((UseCircuitCodePacket)packet, (IPEndPoint)buffer.RemoteEndPoint);
+                Util.FireAndForget(
+                    delegate(object o)
+                    {
+                        IPEndPoint remoteEndPoint = (IPEndPoint)buffer.RemoteEndPoint;
+
+                        // Begin the process of adding the client to the simulator
+                        AddNewClient((UseCircuitCodePacket)packet, remoteEndPoint);
+
+                        // Acknowledge the UseCircuitCode packet
+                        SendAckImmediate(remoteEndPoint, packet.Header.Sequence);
+                    }
+                );
+                return;
             }
 
             // Determine which agent this packet came from
             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 +
+                m_log.Debug("[LLUDPSERVER]: Received a " + packet.Type + " packet from an unrecognized source: " + address +
                     " in " + m_scene.RegionInfo.RegionName + ", currently tracking " + m_scene.ClientManager.Count + " clients");
                 return;
             }
@@ -528,19 +582,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // Stats tracking
             Interlocked.Increment(ref udpClient.PacketsReceived);
 
-            #region ACK Receiving
-
-            int now = Environment.TickCount;
+            int now = Environment.TickCount & Int32.MaxValue;
             udpClient.TickLastPacketReceived = now;
 
+            #region ACK Receiving
+
             // Handle appended ACKs
             if (packet.Header.AppendedAcks && packet.Header.AckList != null)
             {
-                lock (udpClient.NeedAcks.SyncRoot)
-                {
-                    for (int i = 0; i < packet.Header.AckList.Length; i++)
-                        AcknowledgePacket(udpClient, packet.Header.AckList[i], now, packet.Header.Resent);
-                }
+                for (int i = 0; i < packet.Header.AckList.Length; i++)
+                    udpClient.NeedAcks.Remove(packet.Header.AckList[i], now, packet.Header.Resent);
             }
 
             // Handle PacketAck packets
@@ -548,11 +599,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 PacketAckPacket ackPacket = (PacketAckPacket)packet;
 
-                lock (udpClient.NeedAcks.SyncRoot)
-                {
-                    for (int i = 0; i < ackPacket.Packets.Length; i++)
-                        AcknowledgePacket(udpClient, ackPacket.Packets[i].ID, now, packet.Header.Resent);
-                }
+                for (int i = 0; i < ackPacket.Packets.Length; i++)
+                    udpClient.NeedAcks.Remove(ackPacket.Packets[i].ID, now, packet.Header.Resent);
+
+                // We don't need to do anything else with PacketAck packets
+                return;
             }
 
             #endregion ACK Receiving
@@ -560,20 +611,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             #region ACK Sending
 
             if (packet.Header.Reliable)
+            {
                 udpClient.PendingAcks.Enqueue(packet.Header.Sequence);
 
-            // This is a somewhat odd sequence of steps to pull the client.BytesSinceLastACK value out,
-            // add the current received bytes to it, test if 2*MTU bytes have been sent, if so remove
-            // 2*MTU bytes from the value and send ACKs, and finally add the local value back to
-            // client.BytesSinceLastACK. Lockless thread safety
-            int bytesSinceLastACK = Interlocked.Exchange(ref udpClient.BytesSinceLastACK, 0);
-            bytesSinceLastACK += buffer.DataLength;
-            if (bytesSinceLastACK > Packet.MTU * 2)
-            {
-                bytesSinceLastACK -= Packet.MTU * 2;
-                SendAcks(udpClient);
+                // This is a somewhat odd sequence of steps to pull the client.BytesSinceLastACK value out,
+                // add the current received bytes to it, test if 2*MTU bytes have been sent, if so remove
+                // 2*MTU bytes from the value and send ACKs, and finally add the local value back to
+                // client.BytesSinceLastACK. Lockless thread safety
+                int bytesSinceLastACK = Interlocked.Exchange(ref udpClient.BytesSinceLastACK, 0);
+                bytesSinceLastACK += buffer.DataLength;
+                if (bytesSinceLastACK > LLUDPServer.MTU * 2)
+                {
+                    bytesSinceLastACK -= LLUDPServer.MTU * 2;
+                    SendAcks(udpClient);
+                }
+                Interlocked.Add(ref udpClient.BytesSinceLastACK, bytesSinceLastACK);
             }
-            Interlocked.Add(ref udpClient.BytesSinceLastACK, bytesSinceLastACK);
 
             #endregion ACK Sending
 
@@ -593,16 +646,47 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             #endregion Incoming Packet Accounting
 
-            // Don't bother clogging up the queue with PacketAck packets that are already handled here
-            if (packet.Type != PacketType.PacketAck)
+            #region Ping Check Handling
+
+            if (packet.Type == PacketType.StartPingCheck)
             {
-                // Inbox insertion
-                packetInbox.Enqueue(new IncomingPacket(udpClient, packet));
+                // We don't need to do anything else with ping checks
+                StartPingCheckPacket startPing = (StartPingCheckPacket)packet;
+
+                CompletePingCheckPacket completePing = new CompletePingCheckPacket();
+                completePing.PingID.PingID = startPing.PingID.PingID;
+                SendPacket(udpClient, completePing, ThrottleOutPacketType.Unknown, false);
+                return;
             }
+            else if (packet.Type == PacketType.CompletePingCheck)
+            {
+                // We don't currently track client ping times
+                return;
+            }
+
+            #endregion Ping Check Handling
+
+            // Inbox insertion
+            packetInbox.Enqueue(new IncomingPacket(udpClient, packet));
         }
 
-        protected override void PacketSent(UDPPacketBuffer buffer, int bytesSent)
+        private void SendAckImmediate(IPEndPoint remoteEndpoint, uint sequenceNumber)
         {
+            PacketAckPacket ack = new PacketAckPacket();
+            ack.Header.Reliable = false;
+            ack.Packets = new PacketAckPacket.PacketsBlock[1];
+            ack.Packets[0] = new PacketAckPacket.PacketsBlock();
+            ack.Packets[0].ID = sequenceNumber;
+
+            byte[] packetData = ack.ToBytes();
+            int length = packetData.Length;
+
+            UDPPacketBuffer buffer = new UDPPacketBuffer(remoteEndpoint, length);
+            buffer.DataLength = length;
+
+            Buffer.BlockCopy(packetData, 0, buffer.Data, 0, length);
+
+            AsyncBeginSend(buffer);
         }
 
         private bool IsClientAuthorized(UseCircuitCodePacket useCircuitCode, out AuthenticateResponse sessionInfo)
@@ -672,33 +756,25 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 client.Close();
         }
 
-        private void AcknowledgePacket(LLUDPClient client, uint ack, int currentTime, bool fromResend)
-        {
-            OutgoingPacket ackedPacket;
-            if (client.NeedAcks.RemoveUnsafe(ack, out ackedPacket) && !fromResend)
-            {
-                // Update stats
-                Interlocked.Add(ref client.UnackedBytes, -ackedPacket.Buffer.DataLength);
-
-                // Calculate the round-trip time for this packet and its ACK
-                int rtt = currentTime - ackedPacket.TickCount;
-                if (rtt > 0)
-                    client.UpdateRoundTrip(rtt);
-            }
-        }
-
         private void IncomingPacketHandler()
         {
             // Set this culture for the thread that incoming packets are received
             // on to en-US to avoid number parsing issues
             Culture.SetCurrentCulture();
 
-            IncomingPacket incomingPacket = null;
-
             while (base.IsRunning)
             {
-                if (packetInbox.Dequeue(100, ref incomingPacket))
-                    Util.FireAndForget(ProcessInPacket, incomingPacket);
+                try
+                {
+                    IncomingPacket incomingPacket = null;
+
+                    if (packetInbox.Dequeue(100, ref incomingPacket))
+                        Util.FireAndForget(ProcessInPacket, incomingPacket);
+                }
+                catch (Exception ex)
+                {
+                    m_log.Error("[LLUDPSERVER]: Error in the incoming packet handler loop: " + ex.Message, ex);
+                }
             }
 
             if (packetInbox.Count > 0)
@@ -712,68 +788,97 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // on to en-US to avoid number parsing issues
             Culture.SetCurrentCulture();
 
-            int now = Environment.TickCount;
-            int elapsedMS = 0;
-            int elapsed100MS = 0;
-            int elapsed500MS = 0;
-
             while (base.IsRunning)
             {
-                bool resendUnacked = false;
-                bool sendAcks = false;
-                bool sendPings = false;
-                bool packetSent = false;
+                try
+                {
+                    m_packetSent = false;
 
-                elapsedMS += Environment.TickCount - now;
+                    #region Update Timers
 
-                // Check for pending outgoing resends every 100ms
-                if (elapsedMS >= 100)
-                {
-                    resendUnacked = true;
-                    elapsedMS -= 100;
-                    ++elapsed100MS;
+                    m_resendUnacked = false;
+                    m_sendAcks = false;
+                    m_sendPing = false;
+
+                    // Update elapsed time
+                    int thisTick = Environment.TickCount & Int32.MaxValue;
+                    if (m_tickLastOutgoingPacketHandler > thisTick)
+                        m_elapsedMSOutgoingPacketHandler += ((Int32.MaxValue - m_tickLastOutgoingPacketHandler) + thisTick);
+                    else
+                        m_elapsedMSOutgoingPacketHandler += (thisTick - m_tickLastOutgoingPacketHandler);
+
+                    m_tickLastOutgoingPacketHandler = thisTick;
+
+                    // Check for pending outgoing resends every 100ms
+                    if (m_elapsedMSOutgoingPacketHandler >= 100)
+                    {
+                        m_resendUnacked = true;
+                        m_elapsedMSOutgoingPacketHandler = 0;
+                        m_elapsed100MSOutgoingPacketHandler += 1;
+                    }
+
+                    // Check for pending outgoing ACKs every 500ms
+                    if (m_elapsed100MSOutgoingPacketHandler >= 5)
+                    {
+                        m_sendAcks = true;
+                        m_elapsed100MSOutgoingPacketHandler = 0;
+                        m_elapsed500MSOutgoingPacketHandler += 1;
+                    }
+
+                    // Send pings to clients every 5000ms
+                    if (m_elapsed500MSOutgoingPacketHandler >= 10)
+                    {
+                        m_sendPing = true;
+                        m_elapsed500MSOutgoingPacketHandler = 0;
+                    }
+
+                    #endregion Update Timers
+
+                    // Handle outgoing packets, resends, acknowledgements, and pings for each
+                    // client. m_packetSent will be set to true if a packet is sent
+                    m_scene.ClientManager.ForEachSync(ClientOutgoingPacketHandler);
+
+                    // If nothing was sent, sleep for the minimum amount of time before a
+                    // token bucket could get more tokens
+                    if (!m_packetSent)
+                        Thread.Sleep((int)TickCountResolution);
                 }
-                // Check for pending outgoing ACKs every 500ms
-                if (elapsed100MS >= 5)
+                catch (Exception ex)
                 {
-                    sendAcks = true;
-                    elapsed100MS = 0;
-                    ++elapsed500MS;
+                    m_log.Error("[LLUDPSERVER]: OutgoingPacketHandler loop threw an exception: " + ex.Message, ex);
                 }
-                // Send pings to clients every 5000ms
-                if (elapsed500MS >= 10)
+            }
+        }
+
+        private void ClientOutgoingPacketHandler(IClientAPI client)
+        {
+            try
+            {
+                if (client is LLClientView)
                 {
-                    sendPings = true;
-                    elapsed500MS = 0;
-                }
+                    LLUDPClient udpClient = ((LLClientView)client).UDPClient;
 
-                m_scene.ClientManager.ForEach(
-                    delegate(IClientAPI client)
+                    if (udpClient.IsConnected)
                     {
-                        if (client is LLClientView)
-                        {
-                            LLUDPClient udpClient = ((LLClientView)client).UDPClient;
-
-                            if (udpClient.IsConnected)
-                            {
-                                if (udpClient.DequeueOutgoing())
-                                    packetSent = true;
-                                if (resendUnacked)
-                                    ResendUnacked(udpClient);
-                                if (sendAcks)
-                                {
-                                    SendAcks(udpClient);
-                                    udpClient.SendPacketStats();
-                                }
-                                if (sendPings)
-                                    SendPing(udpClient);
-                            }
-                        }
-                    }
-                );
+                        if (m_resendUnacked)
+                            ResendUnacked(udpClient);
+
+                        if (m_sendAcks)
+                            SendAcks(udpClient);
+
+                        if (m_sendPing)
+                            SendPing(udpClient);
 
-                if (!packetSent)
-                    Thread.Sleep(20);
+                        // Dequeue any outgoing packets that are within the throttle limits
+                        if (udpClient.DequeueOutgoing())
+                            m_packetSent = true;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                m_log.Error("[LLUDPSERVER]: OutgoingPacketHandler iteration for " + client.Name +
+                    " threw an exception: " + ex.Message, ex);
             }
         }