diff --git a/.nant/local.include b/.nant/local.include
index f78c6a6987..5e02665f2a 100644
--- a/.nant/local.include
+++ b/.nant/local.include
@@ -58,10 +58,12 @@
+
@@ -115,16 +117,18 @@
+
@@ -238,10 +242,12 @@
+
@@ -271,7 +277,7 @@
-
+
diff --git a/OpenSim/Framework/AvatarAppearance.cs b/OpenSim/Framework/AvatarAppearance.cs
index 3f4214e580..56fcc150aa 100644
--- a/OpenSim/Framework/AvatarAppearance.cs
+++ b/OpenSim/Framework/AvatarAppearance.cs
@@ -66,6 +66,8 @@ namespace OpenSim.Framework
private static UUID SHIRT_ITEM = new UUID("77c41e39-38f9-f75a-0000-585989bf0000");
private static UUID PANTS_ASSET = new UUID("00000000-38f9-1111-024e-222222111120");
private static UUID PANTS_ITEM = new UUID("77c41e39-38f9-f75a-0000-5859892f1111");
+ private static UUID HAIR_ASSET = new UUID("d342e6c0-b9d2-11dc-95ff-0800200c9a66");
+ private static UUID HAIR_ITEM = new UUID("d342e6c1-b9d2-11dc-95ff-0800200c9a66");
public readonly static int VISUALPARAM_COUNT = 218;
@@ -238,6 +240,8 @@ namespace OpenSim.Framework
m_wearables[BODY].ItemID = BODY_ITEM;
m_wearables[SKIN].AssetID = SKIN_ASSET;
m_wearables[SKIN].ItemID = SKIN_ITEM;
+ m_wearables[HAIR].AssetID = HAIR_ASSET;
+ m_wearables[HAIR].ItemID = HAIR_ITEM;
m_wearables[SHIRT].AssetID = SHIRT_ASSET;
m_wearables[SHIRT].ItemID = SHIRT_ITEM;
m_wearables[PANTS].AssetID = PANTS_ASSET;
diff --git a/OpenSim/Framework/AvatarWearable.cs b/OpenSim/Framework/AvatarWearable.cs
index 4a5253ceb3..87d9e617b8 100644
--- a/OpenSim/Framework/AvatarWearable.cs
+++ b/OpenSim/Framework/AvatarWearable.cs
@@ -60,6 +60,10 @@ namespace OpenSim.Framework
// Body
defaultWearables[0].ItemID = new UUID("66c41e39-38f9-f75a-024e-585989bfaba9");
defaultWearables[0].AssetID = new UUID("66c41e39-38f9-f75a-024e-585989bfab73");
+
+ // Hair
+ defaultWearables[2].ItemID = new UUID("d342e6c1-b9d2-11dc-95ff-0800200c9a66");
+ defaultWearables[2].AssetID = new UUID("d342e6c0-b9d2-11dc-95ff-0800200c9a66");
// Skin
defaultWearables[1].ItemID = new UUID("77c41e39-38f9-f75a-024e-585989bfabc9");
diff --git a/OpenSim/Framework/Communications/CommunicationsManager.cs b/OpenSim/Framework/Communications/CommunicationsManager.cs
index 2410f31901..4bf9018862 100644
--- a/OpenSim/Framework/Communications/CommunicationsManager.cs
+++ b/OpenSim/Framework/Communications/CommunicationsManager.cs
@@ -209,35 +209,24 @@ namespace OpenSim.Framework.Communications
private string[] doUUIDNameRequest(UUID uuid)
{
- string[] returnstring = new string[0];
- bool doLookup = false;
-
lock (m_nameRequestCache)
{
if (m_nameRequestCache.ContainsKey(uuid))
- {
- returnstring = m_nameRequestCache[uuid];
- }
- else
- {
- // we don't want to lock the dictionary while we're doing the lookup
- doLookup = true;
- }
+ return m_nameRequestCache[uuid];
}
- if (doLookup) {
- UserProfileData profileData = m_userService.GetUserProfile(uuid);
- if (profileData != null)
+ string[] returnstring = new string[0];
+ CachedUserInfo uinfo = UserProfileCacheService.GetUserDetails(uuid);
+
+ if ((uinfo != null) && (uinfo.UserProfile != null))
+ {
+ returnstring = new string[2];
+ returnstring[0] = uinfo.UserProfile.FirstName;
+ returnstring[1] = uinfo.UserProfile.SurName;
+ lock (m_nameRequestCache)
{
- returnstring = new string[2];
- // UUID profileId = profileData.ID;
- returnstring[0] = profileData.FirstName;
- returnstring[1] = profileData.SurName;
- lock (m_nameRequestCache)
- {
- if (!m_nameRequestCache.ContainsKey(uuid))
- m_nameRequestCache.Add(uuid, returnstring);
- }
+ if (!m_nameRequestCache.ContainsKey(uuid))
+ m_nameRequestCache.Add(uuid, returnstring);
}
}
diff --git a/OpenSim/Region/Application/OpenSimBase.cs b/OpenSim/Region/Application/OpenSimBase.cs
index 4592c318b5..3df3a1cb47 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);
}
///
@@ -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 2f1face8cf..5877779d2b 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 f6ccf01bc0..dbb9861acc 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 2c5ad85432..03902770ed 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
///
- 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 0000000000..43a68ec98e
--- /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
+//{
+// ///
+// ///
+// ///
+// 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;
+
+
+// ///
+// /// Initialize the UDP packet handler in server mode
+// ///
+// /// Port to listening for incoming UDP packets on
+// public OpenSimUDPBase(int port)
+// {
+// udpPort = port;
+// }
+
+// ///
+// /// Initialize the UDP packet handler in client mode
+// ///
+// /// Remote UDP server to connect to
+// public OpenSimUDPBase(IPEndPoint endPoint)
+// {
+// remoteEndPoint = endPoint;
+// udpPort = 0;
+// }
+
+// ///
+// ///
+// ///
+// 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();
+// }
+// }
+
+// ///
+// ///
+// ///
+// 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);
+// }
+// }
+// }
+
+// ///
+// ///
+// ///
+// 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 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 wrappedBuffer = (WrappedObject)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
+{
+ ///
+ ///
+ ///
+ 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;
+
+ ///
+ /// Initialize the UDP packet handler in server mode
+ ///
+ /// Port to listening for incoming UDP packets on
+ public OpenSimUDPBase(int port)
+ {
+ udpPort = port;
+ }
+
+ ///
+ /// Initialize the UDP packet handler in client mode
+ ///
+ /// Remote UDP server to connect to
+ public OpenSimUDPBase(IPEndPoint endPoint)
+ {
+ remoteEndPoint = endPoint;
+ udpPort = 0;
+ }
+
+ ///
+ ///
+ ///
+ 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();
+ }
+ }
+
+ ///
+ ///
+ ///
+ 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();
+ }
+ }
+
+ ///
+ ///
+ ///
+ public bool IsRunning
+ {
+ get { return !shutdownFlag; }
+ }
+
+ private void AsyncBeginReceive()
+ {
+ // allocate a packet buffer
+ //WrappedObject 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 wrappedBuffer = (WrappedObject)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 901144a289..fe9de1b3c5 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 3996cdcaaa..15fb11f19b 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 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 a00ba11d14..bd81d50f39 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 57e1349ffe..78831f8835 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 e6951337e6..847da8c194 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),