mirror of
https://github.com/opensim/opensim.git
synced 2026-06-01 07:15:44 +08:00
8088802c21
These changes replace all direct references to the AssetCache with IAssetCache. There is no change to functionality. Everything works as before. This is laying the groundwork for making it possible to register alternative asset caching mechanisms without disrupting other parts of OpenSim or their dependencies upon AssetCache functionality.
624 lines
25 KiB
C#
624 lines
25 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* 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.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSim Project 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 DEVELOPERS ``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 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.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Reflection;
|
|
using OpenMetaverse.Packets;
|
|
using log4net;
|
|
using Nini.Config;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Framework.Communications.Cache;
|
|
using OpenSim.Region.Framework.Scenes;
|
|
|
|
namespace OpenSim.Region.ClientStack.LindenUDP
|
|
{
|
|
/// <summary>
|
|
/// This class handles the initial UDP circuit setup with a client and passes on subsequent packets to the LLPacketServer
|
|
/// </summary>
|
|
public class LLUDPServer : ILLClientStackNetworkHandler, IClientNetworkServer
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
/// <value>
|
|
/// The client circuits established with this UDP server. If a client exists here we can also assume that
|
|
/// it is populated in clientCircuits_reverse and proxyCircuits (if relevant)
|
|
/// </value>
|
|
protected Dictionary<EndPoint, uint> clientCircuits = new Dictionary<EndPoint, uint>();
|
|
public Hashtable clientCircuits_reverse = Hashtable.Synchronized(new Hashtable());
|
|
protected Dictionary<uint, EndPoint> proxyCircuits = new Dictionary<uint, EndPoint>();
|
|
|
|
private Socket m_socket;
|
|
protected IPEndPoint ServerIncoming;
|
|
protected byte[] RecvBuffer = new byte[4096];
|
|
protected byte[] ZeroBuffer = new byte[8192];
|
|
|
|
/// <value>
|
|
/// This is an endpoint that is reused where we don't need to protect the information from potentially
|
|
/// being stomped on by other threads.
|
|
/// </value>
|
|
protected EndPoint reusedEpSender = new IPEndPoint(IPAddress.Any, 0);
|
|
|
|
protected int proxyPortOffset;
|
|
|
|
protected AsyncCallback ReceivedData;
|
|
protected LLPacketServer m_packetServer;
|
|
protected Location m_location;
|
|
|
|
protected uint listenPort;
|
|
protected bool Allow_Alternate_Port;
|
|
protected IPAddress listenIP = IPAddress.Parse("0.0.0.0");
|
|
protected IScene m_localScene;
|
|
protected IAssetCache m_assetCache;
|
|
|
|
/// <value>
|
|
/// Manages authentication for agent circuits
|
|
/// </value>
|
|
protected AgentCircuitManager m_circuitManager;
|
|
|
|
public IScene LocalScene
|
|
{
|
|
set
|
|
{
|
|
m_localScene = value;
|
|
m_packetServer.LocalScene = m_localScene;
|
|
|
|
m_location = new Location(m_localScene.RegionInfo.RegionHandle);
|
|
}
|
|
}
|
|
|
|
public ulong RegionHandle
|
|
{
|
|
get { return m_location.RegionHandle; }
|
|
}
|
|
|
|
Socket IClientNetworkServer.Server
|
|
{
|
|
get { return m_socket; }
|
|
}
|
|
|
|
public bool HandlesRegion(Location x)
|
|
{
|
|
//return x.RegionHandle == m_location.RegionHandle;
|
|
return x == m_location;
|
|
}
|
|
|
|
public void AddScene(Scene x)
|
|
{
|
|
LocalScene = x;
|
|
}
|
|
|
|
public void Start()
|
|
{
|
|
ServerListener();
|
|
}
|
|
|
|
public void Stop()
|
|
{
|
|
m_socket.Close();
|
|
}
|
|
|
|
public LLUDPServer()
|
|
{
|
|
}
|
|
|
|
public LLUDPServer(
|
|
IPAddress _listenIP, ref uint port, int proxyPortOffset, bool allow_alternate_port, IConfigSource configSource,
|
|
IAssetCache assetCache, AgentCircuitManager authenticateClass)
|
|
{
|
|
Initialise(_listenIP, ref port, proxyPortOffset, allow_alternate_port, configSource, assetCache, authenticateClass);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize the server
|
|
/// </summary>
|
|
/// <param name="_listenIP"></param>
|
|
/// <param name="port"></param>
|
|
/// <param name="proxyPortOffsetParm"></param>
|
|
/// <param name="allow_alternate_port"></param>
|
|
/// <param name="configSource"></param>
|
|
/// <param name="assetCache"></param>
|
|
/// <param name="circuitManager"></param>
|
|
public void Initialise(
|
|
IPAddress _listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port, IConfigSource configSource,
|
|
IAssetCache assetCache, AgentCircuitManager circuitManager)
|
|
{
|
|
ClientStackUserSettings userSettings = new ClientStackUserSettings();
|
|
|
|
IConfig config = configSource.Configs["ClientStack.LindenUDP"];
|
|
|
|
if (config != null)
|
|
{
|
|
if (config.Contains("client_throttle_multiplier"))
|
|
userSettings.ClientThrottleMultipler = config.GetFloat("client_throttle_multiplier");
|
|
}
|
|
|
|
m_log.DebugFormat("[CLIENT]: client_throttle_multiplier = {0}", userSettings.ClientThrottleMultipler);
|
|
|
|
proxyPortOffset = proxyPortOffsetParm;
|
|
listenPort = (uint) (port + proxyPortOffsetParm);
|
|
listenIP = _listenIP;
|
|
Allow_Alternate_Port = allow_alternate_port;
|
|
m_assetCache = assetCache;
|
|
m_circuitManager = circuitManager;
|
|
CreatePacketServer(userSettings);
|
|
|
|
// Return new port
|
|
// This because in Grid mode it is not really important what port the region listens to as long as it is correctly registered.
|
|
// So the option allow_alternate_ports="true" was added to default.xml
|
|
port = (uint)(listenPort - proxyPortOffsetParm);
|
|
}
|
|
|
|
protected virtual void CreatePacketServer(ClientStackUserSettings userSettings)
|
|
{
|
|
new LLPacketServer(this, userSettings);
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method is called every time that we receive new UDP data.
|
|
/// </summary>
|
|
/// <param name="result"></param>
|
|
protected virtual void OnReceivedData(IAsyncResult result)
|
|
{
|
|
Packet packet = null;
|
|
int numBytes = 1;
|
|
EndPoint epSender = new IPEndPoint(IPAddress.Any, 0);
|
|
|
|
if (EndReceive(out numBytes, result, ref epSender))
|
|
{
|
|
// Make sure we are getting zeroes when running off the
|
|
// end of grab / degrab packets from old clients
|
|
Array.Clear(RecvBuffer, numBytes, RecvBuffer.Length - numBytes);
|
|
|
|
int packetEnd = numBytes - 1;
|
|
if (proxyPortOffset != 0) packetEnd -= 6;
|
|
|
|
try
|
|
{
|
|
packet = PacketPool.Instance.GetPacket(RecvBuffer, ref packetEnd, ZeroBuffer);
|
|
}
|
|
catch (MalformedDataException e)
|
|
{
|
|
m_log.DebugFormat("[CLIENT]: Dropped Malformed Packet due to MalformedDataException: {0}", e.StackTrace);
|
|
}
|
|
catch (IndexOutOfRangeException e)
|
|
{
|
|
m_log.DebugFormat("[CLIENT]: Dropped Malformed Packet due to IndexOutOfRangeException: {0}", e.StackTrace);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Debug("[CLIENT]: " + e);
|
|
}
|
|
}
|
|
|
|
EndPoint epProxy = null;
|
|
|
|
if (proxyPortOffset != 0)
|
|
{
|
|
// If we've received a use circuit packet, then we need to decode an endpoint proxy, if one exists,
|
|
// before allowing the RecvBuffer to be overwritten by the next packet.
|
|
if (packet != null && packet.Type == PacketType.UseCircuitCode)
|
|
{
|
|
epProxy = epSender;
|
|
}
|
|
|
|
// Now decode the message from the proxy server
|
|
epSender = ProxyCodec.DecodeProxyMessage(RecvBuffer, ref numBytes);
|
|
}
|
|
|
|
BeginRobustReceive();
|
|
|
|
if (packet != null)
|
|
{
|
|
if (packet.Type == PacketType.UseCircuitCode)
|
|
AddNewClient((UseCircuitCodePacket)packet, epSender, epProxy);
|
|
else
|
|
ProcessInPacket(packet, epSender);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Process a successfully received packet.
|
|
/// </summary>
|
|
/// <param name="packet"></param>
|
|
/// <param name="epSender"></param>
|
|
protected virtual void ProcessInPacket(Packet packet, EndPoint epSender)
|
|
{
|
|
try
|
|
{
|
|
// do we already have a circuit for this endpoint
|
|
uint circuit;
|
|
bool ret;
|
|
|
|
lock (clientCircuits)
|
|
{
|
|
ret = clientCircuits.TryGetValue(epSender, out circuit);
|
|
}
|
|
|
|
if (ret)
|
|
{
|
|
//if so then send packet to the packetserver
|
|
//m_log.DebugFormat(
|
|
// "[UDPSERVER]: For circuit {0} {1} got packet {2}", circuit, epSender, packet.Type);
|
|
|
|
m_packetServer.InPacket(circuit, packet);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Error("[CLIENT]: Exception in processing packet - ignoring: ", e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Begin an asynchronous receive of the next bit of raw data
|
|
/// </summary>
|
|
protected virtual void BeginReceive()
|
|
{
|
|
m_socket.BeginReceiveFrom(
|
|
RecvBuffer, 0, RecvBuffer.Length, SocketFlags.None, ref reusedEpSender, ReceivedData, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Begin a robust asynchronous receive of the next bit of raw data. Robust means that SocketExceptions are
|
|
/// automatically dealt with until the next set of valid UDP data is received.
|
|
/// </summary>
|
|
private void BeginRobustReceive()
|
|
{
|
|
try
|
|
{
|
|
BeginReceive();
|
|
}
|
|
catch (SocketException e)
|
|
{
|
|
// ENDLESS LOOP ON PURPOSE!
|
|
// Reset connection and get next UDP packet off the buffer
|
|
// If the UDP packet is part of the same stream, this will happen several hundreds of times before
|
|
// the next set of UDP data is for a valid client.
|
|
ResetServerEndPoint(e);
|
|
}
|
|
catch (System.ObjectDisposedException)
|
|
{
|
|
m_log.Info("[UDPSERVER]: UDP Object disposed. No need to worry about this if you're restarting the simulator.");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset the server endpoint
|
|
/// </summary>
|
|
/// <param name="e">
|
|
/// The exception that has triggered the reset. Can be null if there was no exception.
|
|
/// </param>
|
|
private void ResetServerEndPoint(Exception e)
|
|
{
|
|
try
|
|
{
|
|
CloseCircuit(e);
|
|
}
|
|
catch (Exception e2)
|
|
{
|
|
m_log.ErrorFormat(
|
|
"[CLIENT]: Exception thrown when trying to close the circuit for {0} - {1}", reusedEpSender, e2);
|
|
}
|
|
|
|
// ENDLESS LOOP ON PURPOSE!
|
|
// We need to purge the UDP stream of crap from the client that disconnected nastily or the UDP server will die
|
|
// The only way to do that is to BeginRobustReceive again!
|
|
BeginRobustReceive();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Close a client circuit. This is done in response to an exception on receive, and should not be called
|
|
/// normally.
|
|
/// </summary>
|
|
/// <param name="e">The exception that caused the close. Can be null if there was no exception</param>
|
|
private void CloseCircuit(Exception e)
|
|
{
|
|
uint circuit;
|
|
lock (clientCircuits)
|
|
{
|
|
if (clientCircuits.TryGetValue(reusedEpSender, out circuit))
|
|
{
|
|
m_packetServer.CloseCircuit(circuit);
|
|
|
|
if (e != null)
|
|
m_log.ErrorFormat(
|
|
"[CLIENT]: Closed circuit {0} {1} due to exception {2}", circuit, reusedEpSender, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finish the process of asynchronously receiving the next bit of raw data
|
|
/// </summary>
|
|
/// <param name="numBytes">The number of bytes received. Will return 0 if no bytes were recieved
|
|
/// <param name="result"></param>
|
|
/// <param name="epSender">The sender of the data</param>
|
|
/// <returns></returns>
|
|
protected virtual bool EndReceive(out int numBytes, IAsyncResult result, ref EndPoint epSender)
|
|
{
|
|
bool hasReceivedOkay = false;
|
|
numBytes = 0;
|
|
|
|
try
|
|
{
|
|
numBytes = m_socket.EndReceiveFrom(result, ref epSender);
|
|
hasReceivedOkay = true;
|
|
}
|
|
catch (SocketException e)
|
|
{
|
|
// TODO : Actually only handle those states that we have control over, re-throw everything else,
|
|
// TODO: implement cases as we encounter them.
|
|
//m_log.Error("[CLIENT]: Connection Error! - " + e.ToString());
|
|
switch (e.SocketErrorCode)
|
|
{
|
|
case SocketError.AlreadyInProgress:
|
|
return hasReceivedOkay;
|
|
|
|
case SocketError.NetworkReset:
|
|
case SocketError.ConnectionReset:
|
|
break;
|
|
|
|
default:
|
|
throw;
|
|
}
|
|
}
|
|
catch (ObjectDisposedException e)
|
|
{
|
|
m_log.DebugFormat("[CLIENT]: ObjectDisposedException: Object {0} disposed.", e.ObjectName);
|
|
// Uhh, what object, and why? this needs better handling.
|
|
}
|
|
|
|
return hasReceivedOkay;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a new client circuit.
|
|
/// </summary>
|
|
/// <param name="packet"></param>
|
|
/// <param name="epSender"></param>
|
|
/// <param name="epProxy"></param>
|
|
protected virtual void AddNewClient(UseCircuitCodePacket useCircuit, EndPoint epSender, EndPoint epProxy)
|
|
{
|
|
//Slave regions don't accept new clients
|
|
if (m_localScene.Region_Status != RegionStatus.SlaveScene)
|
|
{
|
|
AuthenticateResponse sessionInfo;
|
|
bool isNewCircuit = false;
|
|
|
|
if (!m_packetServer.IsClientAuthorized(useCircuit, m_circuitManager, out sessionInfo))
|
|
{
|
|
m_log.WarnFormat(
|
|
"[CONNECTION FAILURE]: Connection request for client {0} connecting with unnotified circuit code {1} from {2}",
|
|
useCircuit.CircuitCode.ID, useCircuit.CircuitCode.Code, epSender);
|
|
|
|
return;
|
|
}
|
|
|
|
lock (clientCircuits)
|
|
{
|
|
if (!clientCircuits.ContainsKey(epSender))
|
|
{
|
|
clientCircuits.Add(epSender, useCircuit.CircuitCode.Code);
|
|
isNewCircuit = true;
|
|
}
|
|
}
|
|
|
|
if (isNewCircuit)
|
|
{
|
|
// This doesn't need locking as it's synchronized data
|
|
clientCircuits_reverse[useCircuit.CircuitCode.Code] = epSender;
|
|
|
|
lock (proxyCircuits)
|
|
{
|
|
proxyCircuits[useCircuit.CircuitCode.Code] = epProxy;
|
|
}
|
|
|
|
m_packetServer.AddNewClient(epSender, useCircuit, m_assetCache, sessionInfo, epProxy);
|
|
|
|
m_log.DebugFormat(
|
|
"[CONNECTION SUCCESS]: Incoming client {0} (circuit code {1}) received and authenticated for {2}",
|
|
useCircuit.CircuitCode.ID, useCircuit.CircuitCode.Code, m_localScene.RegionInfo.RegionName);
|
|
}
|
|
}
|
|
|
|
// Ack the UseCircuitCode packet
|
|
PacketAckPacket ack_it = (PacketAckPacket)PacketPool.Instance.GetPacket(PacketType.PacketAck);
|
|
// TODO: don't create new blocks if recycling an old packet
|
|
ack_it.Packets = new PacketAckPacket.PacketsBlock[1];
|
|
ack_it.Packets[0] = new PacketAckPacket.PacketsBlock();
|
|
ack_it.Packets[0].ID = useCircuit.Header.Sequence;
|
|
// ((useCircuit.Header.Sequence < uint.MaxValue) ? useCircuit.Header.Sequence : 0) is just a failsafe to ensure that we don't overflow.
|
|
ack_it.Header.Sequence = ((useCircuit.Header.Sequence < uint.MaxValue) ? useCircuit.Header.Sequence : 0) + 1;
|
|
ack_it.Header.Reliable = false;
|
|
|
|
byte[] ackmsg = ack_it.ToBytes();
|
|
|
|
// Need some extra space in case we need to add proxy
|
|
// information to the message later
|
|
byte[] msg = new byte[4096];
|
|
Buffer.BlockCopy(ackmsg, 0, msg, 0, ackmsg.Length);
|
|
|
|
SendPacketTo(msg, ackmsg.Length, SocketFlags.None, useCircuit.CircuitCode.Code);
|
|
|
|
PacketPool.Instance.ReturnPacket(useCircuit);
|
|
}
|
|
|
|
public void ServerListener()
|
|
{
|
|
uint newPort = listenPort;
|
|
m_log.Info("[UDPSERVER]: Opening UDP socket on " + listenIP + " " + newPort + ".");
|
|
|
|
ServerIncoming = new IPEndPoint(listenIP, (int)newPort);
|
|
m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
m_socket.Bind(ServerIncoming);
|
|
// Add flags to the UDP socket to prevent "Socket forcibly closed by host"
|
|
// uint IOC_IN = 0x80000000;
|
|
// uint IOC_VENDOR = 0x18000000;
|
|
// uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;
|
|
// TODO: this apparently works in .NET but not in Mono, need to sort out the right flags here.
|
|
// m_socket.IOControl((int)SIO_UDP_CONNRESET, new byte[] { Convert.ToByte(false) }, null);
|
|
|
|
listenPort = newPort;
|
|
|
|
m_log.Info("[UDPSERVER]: UDP socket bound, getting ready to listen");
|
|
|
|
ReceivedData = OnReceivedData;
|
|
BeginReceive();
|
|
|
|
m_log.Info("[UDPSERVER]: Listening on port " + newPort);
|
|
}
|
|
|
|
public virtual void RegisterPacketServer(LLPacketServer server)
|
|
{
|
|
m_packetServer = server;
|
|
}
|
|
|
|
public virtual void SendPacketTo(byte[] buffer, int size, SocketFlags flags, uint circuitcode)
|
|
//EndPoint packetSender)
|
|
{
|
|
// find the endpoint for this circuit
|
|
EndPoint sendto;
|
|
try
|
|
{
|
|
sendto = (EndPoint)clientCircuits_reverse[circuitcode];
|
|
}
|
|
catch
|
|
{
|
|
// Exceptions here mean there is no circuit
|
|
m_log.Warn("[CLIENT]: Circuit not found, not sending packet");
|
|
return;
|
|
}
|
|
|
|
if (sendto != null)
|
|
{
|
|
//we found the endpoint so send the packet to it
|
|
if (proxyPortOffset != 0)
|
|
{
|
|
//MainLog.Instance.Verbose("UDPSERVER", "SendPacketTo proxy " + proxyCircuits[circuitcode].ToString() + ": client " + sendto.ToString());
|
|
ProxyCodec.EncodeProxyMessage(buffer, ref size, sendto);
|
|
m_socket.SendTo(buffer, size, flags, proxyCircuits[circuitcode]);
|
|
}
|
|
else
|
|
{
|
|
//MainLog.Instance.Verbose("UDPSERVER", "SendPacketTo : client " + sendto.ToString());
|
|
try
|
|
{
|
|
m_socket.SendTo(buffer, size, flags, sendto);
|
|
}
|
|
catch (SocketException SockE)
|
|
{
|
|
m_log.ErrorFormat("[UDPSERVER]: Caught Socket Error in the send buffer!. {0}",SockE.ToString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual void RemoveClientCircuit(uint circuitcode)
|
|
{
|
|
EndPoint sendto;
|
|
if (clientCircuits_reverse.Contains(circuitcode))
|
|
{
|
|
sendto = (EndPoint)clientCircuits_reverse[circuitcode];
|
|
|
|
clientCircuits_reverse.Remove(circuitcode);
|
|
|
|
lock (clientCircuits)
|
|
{
|
|
if (sendto != null)
|
|
{
|
|
clientCircuits.Remove(sendto);
|
|
}
|
|
else
|
|
{
|
|
m_log.DebugFormat(
|
|
"[CLIENT]: endpoint for circuit code {0} in RemoveClientCircuit() was unexpectedly null!", circuitcode);
|
|
}
|
|
}
|
|
lock (proxyCircuits)
|
|
{
|
|
proxyCircuits.Remove(circuitcode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RestoreClient(AgentCircuitData circuit, EndPoint userEP, EndPoint proxyEP)
|
|
{
|
|
//MainLog.Instance.Verbose("UDPSERVER", "RestoreClient");
|
|
|
|
UseCircuitCodePacket useCircuit = new UseCircuitCodePacket();
|
|
useCircuit.CircuitCode.Code = circuit.circuitcode;
|
|
useCircuit.CircuitCode.ID = circuit.AgentID;
|
|
useCircuit.CircuitCode.SessionID = circuit.SessionID;
|
|
|
|
AuthenticateResponse sessionInfo;
|
|
|
|
if (!m_packetServer.IsClientAuthorized(useCircuit, m_circuitManager, out sessionInfo))
|
|
{
|
|
m_log.WarnFormat(
|
|
"[CLIENT]: Restore request denied to avatar {0} connecting with unauthorized circuit code {1}",
|
|
useCircuit.CircuitCode.ID, useCircuit.CircuitCode.Code);
|
|
|
|
return;
|
|
}
|
|
|
|
lock (clientCircuits)
|
|
{
|
|
if (!clientCircuits.ContainsKey(userEP))
|
|
clientCircuits.Add(userEP, useCircuit.CircuitCode.Code);
|
|
else
|
|
m_log.Error("[CLIENT]: clientCircuits already contains entry for user " + useCircuit.CircuitCode.Code + ". NOT adding.");
|
|
}
|
|
|
|
// This data structure is synchronized, so we don't need the lock
|
|
if (!clientCircuits_reverse.ContainsKey(useCircuit.CircuitCode.Code))
|
|
clientCircuits_reverse.Add(useCircuit.CircuitCode.Code, userEP);
|
|
else
|
|
m_log.Error("[CLIENT]: clientCurcuits_reverse already contains entry for user " + useCircuit.CircuitCode.Code + ". NOT adding.");
|
|
|
|
lock (proxyCircuits)
|
|
{
|
|
if (!proxyCircuits.ContainsKey(useCircuit.CircuitCode.Code))
|
|
{
|
|
proxyCircuits.Add(useCircuit.CircuitCode.Code, proxyEP);
|
|
}
|
|
else
|
|
{
|
|
// re-set proxy endpoint
|
|
proxyCircuits.Remove(useCircuit.CircuitCode.Code);
|
|
proxyCircuits.Add(useCircuit.CircuitCode.Code, proxyEP);
|
|
}
|
|
}
|
|
|
|
m_packetServer.AddNewClient(userEP, useCircuit, m_assetCache, sessionInfo, proxyEP);
|
|
}
|
|
}
|
|
}
|