1 files changed, 105 insertions, 2 deletions

diff --git a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
index d2779ba..de2cd24 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
@@ -29,6 +29,7 @@ using System;
 using System.Net;
 using System.Net.Sockets;
 using System.Threading;
+using System.Collections.Generic;
 using log4net;
 
 namespace OpenMetaverse
@@ -52,12 +53,30 @@ namespace OpenMetaverse
         /// <summary>Local IP address to bind to in server mode</summary>
         protected IPAddress m_localBindAddress;
 
+        /// <summary>
+        /// Standard queue for our outgoing SyncBeginPrioritySend
+        /// </summary>
+        private List<UDPPacketBuffer> m_standardQueue = new List<UDPPacketBuffer>();
+
+        /// <summary>
+        /// Medium priority queue for our outgoing SyncBeginPrioritySend
+        /// </summary>
+        private List<UDPPacketBuffer> m_mediumPriorityQueue = new List<UDPPacketBuffer>();
+
+        /// <summary>
+        /// Prioritised queue for our outgoing SyncBeginPrioritySend
+        /// </summary>
+        private List<UDPPacketBuffer> m_priorityQueue = new List<UDPPacketBuffer>();
+
         /// <summary>UDP socket, used in either client or server mode</summary>
         private Socket m_udpSocket;
 
         /// <summary>Flag to process packets asynchronously or synchronously</summary>
         private bool m_asyncPacketHandling;
 
+        /// <summary>Are we currently sending data asynchronously?</summary>
+        private volatile bool m_sendingData = false;
+
         /// <summary>The all important shutdown flag</summary>
         private volatile bool m_shutdownFlag = true;
 
@@ -246,7 +265,51 @@ namespace OpenMetaverse
             }
         }
 
-        public void AsyncBeginSend(UDPPacketBuffer buf)
+        public void SyncBeginPrioritySend(UDPPacketBuffer buf, int Priority)
+        {
+            if (!m_shutdownFlag)
+            {
+                if (!m_sendingData)
+                {
+                    m_sendingData = true;
+                    try
+                    {
+                        AsyncBeginSend(buf);
+                    }
+                    catch (SocketException) { }
+                    catch (ObjectDisposedException) { }
+                }
+                else
+                {
+                    if (Priority == 2)
+                    {
+                        lock (m_priorityQueue)
+                        {
+                            m_priorityQueue.Add(buf);
+                        }
+                    }
+                    else
+                    {
+                        if (Priority != 0)
+                        {
+                            lock (m_mediumPriorityQueue)
+                            {
+                                m_mediumPriorityQueue.Add(buf);
+                            }
+                        }
+                        else
+                        {
+                            lock (m_standardQueue)
+                            {
+                                m_standardQueue.Add(buf);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private void AsyncBeginSend(UDPPacketBuffer buf)
         {
             if (!m_shutdownFlag)
             {
@@ -270,8 +333,48 @@ namespace OpenMetaverse
         {
             try
             {
-//                UDPPacketBuffer buf = (UDPPacketBuffer)result.AsyncState;
                 m_udpSocket.EndSendTo(result);
+
+                if (m_sendingData)
+                {
+                    lock (m_priorityQueue)
+                    {
+                        if (m_priorityQueue.Count > 0)
+                        {
+                            UDPPacketBuffer buf = m_priorityQueue[0];
+                            m_priorityQueue.RemoveAt(0);
+                            AsyncBeginSend(buf);
+                        }
+                        else
+                        {
+                            lock (m_mediumPriorityQueue)
+                            {
+                                if (m_mediumPriorityQueue.Count > 0)
+                                {
+                                    UDPPacketBuffer buf = m_mediumPriorityQueue[0];
+                                    m_mediumPriorityQueue.RemoveAt(0);
+                                    AsyncBeginSend(buf);
+                                }
+                                else
+                                {
+                                    lock (m_standardQueue)
+                                    {
+                                        if (m_standardQueue.Count > 0)
+                                        {
+                                            UDPPacketBuffer buf = m_standardQueue[0];
+                                            m_standardQueue.RemoveAt(0);
+                                            AsyncBeginSend(buf);
+                                        }
+                                        else
+                                        {
+                                            m_sendingData = false;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
             catch (SocketException) { }
             catch (ObjectDisposedException) { }