Merge branch 'master' into vehicles

10 files changed, 637 insertions, 28 deletions

diff --git a/OpenSim/Region/Application/OpenSimBase.cs b/OpenSim/Region/Application/OpenSimBase.cs
index 4592c31..3df3a1c 100644
--- a/OpenSim/Region/Application/OpenSimBase.cs
+++ b/OpenSim/Region/Application/OpenSimBase.cs
@@ -459,7 +459,8 @@ namespace OpenSim
 
             scene.DeleteAllSceneObjects();
             m_sceneManager.CloseScene(scene);
-
+            ShutdownClientServer(scene.RegionInfo);
+            
             if (!cleanup)
                 return;
 
@@ -519,7 +520,7 @@ namespace OpenSim
             }
 
             m_sceneManager.CloseScene(scene);
-
+            ShutdownClientServer(scene.RegionInfo);
         }
         
         /// <summary>
@@ -653,12 +654,10 @@ namespace OpenSim
                 storageManager, m_moduleLoader, false, m_configSettings.PhysicalPrim,
                 m_configSettings.See_into_region_from_neighbor, m_config.Source, m_version);
         }
-
-        public void handleRestartRegion(RegionInfo whichRegion)
+        
+        protected void ShutdownClientServer(RegionInfo whichRegion)
         {
-            m_log.Info("[OPENSIM]: Got restart signal from SceneManager");
-
-            // Shutting down the client server
+            // Close and remove the clientserver for a region
             bool foundClientServer = false;
             int clientServerElement = 0;
             Location location = new Location(whichRegion.RegionHandle);
@@ -678,6 +677,13 @@ namespace OpenSim
                 m_clientServers[clientServerElement].NetworkStop();
                 m_clientServers.RemoveAt(clientServerElement);
             }
+        }
+        
+        public void handleRestartRegion(RegionInfo whichRegion)
+        {
+            m_log.Info("[OPENSIM]: Got restart signal from SceneManager");
+
+            ShutdownClientServer(whichRegion);
             IScene scene;
             CreateRegion(whichRegion, true, out scene);
         }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs b/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs
index 2f1face..5877779 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs
@@ -74,6 +74,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public bool SendPackets(LLClientView client, int maxpack)
         {
+            if (client == null)
+                return false;
+
             if (m_currentPacket <= m_stopPacket)
             {
                 int count = 0;
@@ -202,6 +205,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private bool SendFirstPacket(LLClientView client)
         {
+            if (client == null)
+                return false;
+
             if (m_asset == null)
             {
                 m_log.Warn("[J2KIMAGE]: Sending ImageNotInDatabase for texture " + TextureID);
@@ -234,6 +240,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private bool SendPacket(LLClientView client)
         {
+            if (client == null)
+                return false;
+
             bool complete = false;
             int imagePacketSize = ((int)m_currentPacket == (TexturePacketCount())) ? LastPacketSize() : IMAGE_PACKET_SIZE;
 
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClientCollection.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClientCollection.cs
index f6ccf01..dbb9861 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClientCollection.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClientCollection.cs
@@ -224,16 +224,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             ////return success;
 
-            //lock (m_sync)
-            //    return Dictionary1.TryGetValue(key, out value); 
+            lock (m_sync)
+                return Dictionary1.TryGetValue(key, out value); 
 
-            try
-            {
-                return Dictionary1.TryGetValue(key, out value);
-            }
-            catch { }
-            value = null;
-            return false;
+            //try
+            //{
+            //    return Dictionary1.TryGetValue(key, out value);
+            //}
+            //catch { }
+            //value = null;
+            //return false;
         }
 
         public bool TryGetValue(IPEndPoint key, out LLUDPClient value)
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
index 2c5ad85..0390277 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
@@ -87,7 +87,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     /// The LLUDP server for a region. This handles incoming and outgoing
     /// packets for all UDP connections to the region
     /// </summary>
-    public class LLUDPServer : UDPBase
+    public class LLUDPServer : OpenSimUDPBase
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
@@ -287,11 +287,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     // instead
                     m_log.Info("[LLUDPSERVER]: Packet exceeded buffer size during zerocoding. 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;
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
new file mode 100644
index 0000000..43a68ec
--- /dev/null
+++ b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
@@ -0,0 +1,569 @@
+//--------- Modified Version -------------------
+///*
+// * Copyright (c) 2006, Clutch, Inc.
+// * Original Author: Jeff Cesnik
+// * 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.Net;
+using System.Net.Sockets;
+using System.Threading;
+using OpenMetaverse;
+
+//namespace OpenSim.Region.ClientStack.LindenUDP
+//{
+//    /// <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>
+    /// 
+    /// </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 all important shutdownFlag.
+        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)
+            {
+                const int SIO_UDP_CONNRESET = -1744830452;
+
+                IPEndPoint ipep = new IPEndPoint(Settings.BIND_ADDR, udpPort);
+                udpSocket = new Socket(
+                    AddressFamily.InterNetwork,
+                    SocketType.Dgram,
+                    ProtocolType.Udp);
+                try
+                {
+                    // 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);
+                }
+                catch (SocketException)
+                {
+                    Logger.DebugLog("UDP SIO_UDP_CONNRESET flag not supported on this platform");
+                }
+                udpSocket.Bind(ipep);
+
+                // 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.
+                shutdownFlag = true;
+                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)
+            {
+                try
+                {
+                    // kick off an async read
+                    udpSocket.BeginReceiveFrom(
+                        //wrappedBuffer.Instance.Data,
+                        buf.Data,
+                        0,
+                        UDPPacketBuffer.BUFFER_SIZE,
+                        SocketFlags.None,
+                        ref buf.RemoteEndPoint,
+                        AsyncEndReceive,
+                        //wrappedBuffer);
+                        buf);
+                }
+                catch (SocketException e)
+                {
+                    if (e.SocketErrorCode == SocketError.ConnectionReset)
+                    {
+                        Logger.Log("SIO_UDP_CONNRESET was ignored, attempting to salvage the UDP listener on port " + udpPort, Helpers.LogLevel.Error);
+                        bool salvaged = false;
+                        while (!salvaged)
+                        {
+                            try
+                            {
+                                udpSocket.BeginReceiveFrom(
+                                    //wrappedBuffer.Instance.Data,
+                                    buf.Data,
+                                    0,
+                                    UDPPacketBuffer.BUFFER_SIZE,
+                                    SocketFlags.None,
+                                    ref buf.RemoteEndPoint,
+                                    AsyncEndReceive,
+                                    //wrappedBuffer);
+                                    buf);
+                                salvaged = true;
+                            }
+                            catch (SocketException) { }
+                            catch (ObjectDisposedException) { return; }
+                        }
+
+                        Logger.Log("Salvaged the UDP listener on port " + udpPort, Helpers.LogLevel.Info);
+                    }
+                }
+                catch (ObjectDisposedException) { }
+            }
+        }
+
+        private void AsyncEndReceive(IAsyncResult iar)
+        {
+            // Asynchronous receive operations will complete here through the call
+            // to AsyncBeginReceive
+            if (!shutdownFlag)
+            {
+                // start another receive - this keeps the server going!
+                AsyncBeginReceive();
+
+                // 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);
+
+                    // call the abstract method PacketReceived(), passing the buffer that
+                    // has just been filled from the socket read.
+                    PacketReceived(buffer);
+                }
+                catch (SocketException) { }
+                catch (ObjectDisposedException) { }
+                //finally { wrappedBuffer.Dispose(); }
+            }
+        }
+
+        public void AsyncBeginSend(UDPPacketBuffer buf)
+        {
+            if (!shutdownFlag)
+            {
+                try
+                {
+                    udpSocket.BeginSendTo(
+                        buf.Data,
+                        0,
+                        buf.DataLength,
+                        SocketFlags.None,
+                        buf.RemoteEndPoint,
+                        AsyncEndSend,
+                        buf);
+                }
+                catch (SocketException) { }
+                catch (ObjectDisposedException) { }
+            }
+        }
+
+        void AsyncEndSend(IAsyncResult result)
+        {
+            try
+            {
+                UDPPacketBuffer buf = (UDPPacketBuffer)result.AsyncState;
+                int bytesSent = udpSocket.EndSendTo(result);
+
+                PacketSent(buf, bytesSent);
+            }
+            catch (SocketException) { }
+            catch (ObjectDisposedException) { }
+        }
+    }
+}
+
diff --git a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
index 901144a..fe9de1b 100644
--- a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
+++ b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
@@ -556,6 +556,8 @@ namespace OpenSim.Region.CoreModules.World.Permissions
 
             // Customize the EveryoneMask
             uint objectEveryoneMask = ApplyObjectModifyMasks(task.EveryoneMask, objflags);
+            if (objectOwner != UUID.Zero)
+                objectEveryoneMask |= (uint)PrimFlags.ObjectAnyOwner;
 
             if (m_bypassPermissions)
                 return objectOwnerMask;
@@ -578,12 +580,9 @@ namespace OpenSim.Region.CoreModules.World.Permissions
             {
                 // Admin objects should not be editable by the above
                 if (!IsAdministrator(objectOwner))
-            return objectOwnerMask;
+                    return objectOwnerMask;
             }
 
-            if ((objectOwnerMask & (uint)PermissionMask.Transfer) != 0 && task.ObjectSaleType != 0)
-                objectEveryoneMask |= (uint)PrimFlags.ObjectTransfer;
-
             // Group permissions
             if ((task.GroupID != UUID.Zero) && IsGroupMember(task.GroupID, user, 0))
                 return objectGroupMask | objectEveryoneMask;
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 3996cdc..15fb11f 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -3409,7 +3409,7 @@ namespace OpenSim.Region.Framework.Scenes
             scene.AddPhysicsActorTaint(m_physicsActor);
             //m_physicsActor.OnRequestTerseUpdate += SendTerseUpdateToAllClients;
             m_physicsActor.OnCollisionUpdate += PhysicsCollisionUpdate;
-            m_physicsActor.SubscribeEvents(1000);
+            m_physicsActor.SubscribeEvents(500);
             m_physicsActor.LocalID = LocalId;
             
         }
@@ -3417,7 +3417,15 @@ namespace OpenSim.Region.Framework.Scenes
         // Event called by the physics plugin to tell the avatar about a collision.
         private void PhysicsCollisionUpdate(EventArgs e)
         {
-            if ((e == null) || m_invulnerable)
+            if (e == null)
+                return;
+
+            //if ((Math.Abs(Velocity.X) > 0.1e-9f) || (Math.Abs(Velocity.Y) > 0.1e-9f))
+            // The Physics Scene will send updates every 500 ms grep: m_physicsActor.SubscribeEvents(
+            // as of this comment the interval is set in AddToPhysicalScene
+            UpdateMovementAnimations();
+
+            if (m_invulnerable)
                 return;
             CollisionEventUpdate collisionData = (CollisionEventUpdate)e;
             Dictionary<uint, float> coldata = collisionData.m_objCollisionList;
@@ -3455,8 +3463,7 @@ namespace OpenSim.Region.Framework.Scenes
                     m_scene.EventManager.TriggerAvatarKill(killerObj, this);
             }
 
-            if (Velocity.X > 0 || Velocity.Y > 0)
-                UpdateMovementAnimations();
+            
         }
 
         public void setHealthWithUpdate(float health)
diff --git a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
index a00ba11..bd81d50 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
@@ -98,6 +98,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         private bool m_alwaysRun = false;
         private bool m_hackSentFall = false;
         private bool m_hackSentFly = false;
+        private int m_requestedUpdateFrequency = 0;
         private PhysicsVector m_taintPosition = new PhysicsVector(0, 0, 0);
         public uint m_localID = 0;
         public bool m_returnCollisions = false;
@@ -1184,26 +1185,31 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         public override void SubscribeEvents(int ms)
         {
+            m_requestedUpdateFrequency = ms;
             m_eventsubscription = ms;
             _parent_scene.addCollisionEventReporting(this);
         }
         public override void UnSubscribeEvents()
         {
             _parent_scene.remCollisionEventReporting(this);
+            m_requestedUpdateFrequency = 0;
             m_eventsubscription = 0;
         }
         public void AddCollisionEvent(uint CollidedWith, float depth)
         {
             if (m_eventsubscription > 0)
-                CollisionEventsThisFrame.addCollider(CollidedWith,depth);
+            {
+                CollisionEventsThisFrame.addCollider(CollidedWith, depth);
+            }
         }
 
         public void SendCollisions()
         {
-            if (m_eventsubscription > 0)
+            if (m_eventsubscription > m_requestedUpdateFrequency)
             {
                 base.SendCollisionUpdate(CollisionEventsThisFrame);
                 CollisionEventsThisFrame = new CollisionEventUpdate();
+                m_eventsubscription = 0;
             }
         }
         public override bool SubscribedEvents()
@@ -1309,5 +1315,13 @@ namespace OpenSim.Region.Physics.OdePlugin
             }
 
         }
+
+        internal void AddCollisionFrameTime(int p)
+        {
+            // protect it from overflow crashing
+            if (m_eventsubscription + p >= int.MaxValue)
+                m_eventsubscription = 0;
+            m_eventsubscription += p;
+        }
     }
 }
diff --git a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
index 57e1349..78831f8 100644
--- a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
+++ b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
@@ -2940,6 +2940,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                                         {
                                             case ActorTypes.Agent:
                                                 OdeCharacter cobj = (OdeCharacter)obj;
+                                                cobj.AddCollisionFrameTime(100);
                                                 cobj.SendCollisions();
                                                 break;
                                             case ActorTypes.Prim:
diff --git a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
index e695133..847da8c 100644
--- a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
+++ b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
@@ -642,7 +642,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                     m_ScriptErrorMessage += "Failed to compile script in object: '" + part.ParentGroup.RootPart.Name + "' Script name: '" + item.Name + "' Error message: " + e.Message.ToString();
 
                     m_ScriptFailCount++;
-                    string text = "Error compiling script:\n" + e.Message.ToString();
+                    string text = "Error compiling script '" + item.Name + "':\n" + e.Message.ToString();
                     if (text.Length > 1000)
                         text = text.Substring(0, 1000);
                     World.SimChat(Utils.StringToBytes(text),