OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' into vehicles

0.6.8-post-fixes
Melanie 2009-10-12 15:11:01 +01:00
parent f6b8bac0fa ef03b2d936
commit 50f509d600
14 changed files with 667 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
.nant/local.include
View File

@ -58,10 +58,12 @@
</exec>
<fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.framework.serialization.tests)==0}" />
<!--
<exec program="${nunitcmd}" failonerror="true" resultproperty="testresult.opensim.region.clientstack.lindenudp.tests">
<arg value="./bin/OpenSim.Region.ClientStack.LindenUDP.Tests.dll" />
</exec>
<fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.region.clientstack.lindenudp.tests)==0}" />
-->
<exec program="${nunitcmd}" failonerror="true" resultproperty="testresult.opensim.region.scriptengine.tests">
<arg value="./bin/OpenSim.Region.ScriptEngine.Tests.dll" />
@ -115,16 +117,18 @@
<arg value="--export-html=./cov/OpenSim.Framework.Servers ./cov/OpenSim.Framework.Communications.cov" />
</exec>
<!--
<exec program="mono">
<arg value="--debug" />
<arg value="--profile=monocov:outfile=./cov/OpenSim.Region.ClientStack.LindenUDP.cov,+[OpenSim.Region.ClientStack.LindenUDP]" />
<arg value="&#45;&#45;debug" />
<arg value="&#45;&#45;profile=monocov:outfile=./cov/OpenSim.Region.ClientStack.LindenUDP.cov,+[OpenSim.Region.ClientStack.LindenUDP]" />
<arg value="/usr/lib/nunit/nunit-console.exe" />
<arg value="./bin/OpenSim.Region.ClientStack.LindenUDP.Tests.dll" />
</exec>
<delete dir="./cov/OpenSim.Region.ClientStack.LindenUDP" />
<exec program="monocov">
<arg value="--export-html=./cov/OpenSim.Region.ClientStack.LindenUDP ./cov/OpenSim.Region.ClientStack.LindenUDP.cov" />
<arg value="&#45;&#45;export-html=./cov/OpenSim.Region.ClientStack.LindenUDP ./cov/OpenSim.Region.ClientStack.LindenUDP.cov" />
</exec>
-->
<exec program="mono">
<arg value="--debug" />
@ -238,10 +242,12 @@
<arg value="-xml=test-results/OpenSim.Framework.Servers.Tests.dll-Results.xml" />
</exec>
<!--
<exec program="${nunitcmd}" failonerror="false" resultproperty="testresult.opensim.region.clientstack.lindenudp.tests">
<arg value="./bin/OpenSim.Region.ClientStack.LindenUDP.Tests.dll" />
<arg value="-xml=test-results/OpenSim.Region.ClientStack.LindenUDP.Tests.dll-Results.xml" />
</exec>
-->
<exec program="${nunitcmd}" failonerror="false" resultproperty="testresult.opensim.region.scriptengine.tests">
<arg value="./bin/OpenSim.Region.ScriptEngine.Tests.dll" />
@ -271,7 +277,7 @@
<fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.framework.tests)==0}" />
<fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.framework.communications.tests)==0}" />
<fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.framework.servers.tests)==0}" />
<fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.region.clientstack.lindenudp.tests)==0}" />
<!-- <fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.region.clientstack.lindenudp.tests)==0}" /> -->
<fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.region.scriptengine.tests)==0}" />
<fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.region.coremodules.tests)==0}" />
<fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.region.framework.tests)==0}" />

4
OpenSim/Framework/AvatarAppearance.cs
View File

@ -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;

4
OpenSim/Framework/AvatarWearable.cs
View File

@ -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");

35
OpenSim/Framework/Communications/CommunicationsManager.cs
View File

@ -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);
}
}

20
OpenSim/Region/Application/OpenSimBase.cs
View File

@ -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);
}

9
OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs
View File

@ -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;

18
OpenSim/Region/ClientStack/LindenUDP/LLUDPClientCollection.cs
View File

@ -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)

6
OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
View File

@ -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;

569
OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs Normal file
View File

@ -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) { }
}
}
}

7
OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
View File

@ -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;

15
OpenSim/Region/Framework/Scenes/ScenePresence.cs
View File

@ -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)

18
OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
View File

@ -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;
}
}
}

1
OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
View File

@ -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:

2
OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
View File

@ -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),