Created skeleton SimComms.cs for sim<->sim UDP circuits

Fixed bug with <0,0> co-ordinates on sim crossing
author: gareth 2007-04-17 10:53:50 +0000
committer: gareth 2007-04-17 10:53:50 +0000
commit: 3e86870f7f1eb3d90089d41f8669fbd22d2e50d4 (patch)
tree: 5e04e36b7725227e95618933a2850898504a12fc
parent: Sim crossing now works (except for broken co-ordinates, resets to 0,0 - to be... (diff)
download: opensim-SC_OLD-3e86870f7f1eb3d90089d41f8669fbd22d2e50d4.zip
opensim-SC_OLD-3e86870f7f1eb3d90089d41f8669fbd22d2e50d4.tar.gz
opensim-SC_OLD-3e86870f7f1eb3d90089d41f8669fbd22d2e50d4.tar.bz2
opensim-SC_OLD-3e86870f7f1eb3d90089d41f8669fbd22d2e50d4.tar.xz
3 files changed, 476 insertions, 4 deletions
diff --git a/OpenSim.RegionServer/OpenSimMain.cs b/OpenSim.RegionServer/OpenSimMain.cs
index 038c7e6..7f2032d 100644
--- a/OpenSim.RegionServer/OpenSimMain.cs
+++ b/OpenSim.RegionServer/OpenSimMain.cs
@@ -222,6 +222,26 @@ namespace OpenSim
                        return new XmlRpcResponse();
                    });
+                httpServer.AddXmlRPCHandler("agent_crossing",
+                    delegate(XmlRpcRequest request)
+                    {
+                        Hashtable requestData = (Hashtable)request.Params[0];
+                        AgentCircuitData agent_data = new AgentCircuitData();
+                        agent_data.firstname = (string)requestData["firstname"];
+                        agent_data.lastname = (string)requestData["lastname"];
+                        agent_data.circuitcode = Convert.ToUInt32(requestData["circuit_code"]);
+                        agent_data.startpos = new LLVector3(Single.Parse((string)requestData["pos_x"]),Single.Parse((string)requestData["pos_y"]),Single.Parse((string)requestData["pos_z"]));
+                        
+                        if(((RemoteGridBase)gridServer).agentcircuits.ContainsKey((uint)agent_data.circuitcode)) {
+                                ((RemoteGridBase)gridServer).agentcircuits[(uint)agent_data.circuitcode].firstname = agent_data.firstname;
+                                ((RemoteGridBase)gridServer).agentcircuits[(uint)agent_data.circuitcode].lastname  = agent_data.lastname;
+                                ((RemoteGridBase)gridServer).agentcircuits[(uint)agent_data.circuitcode].startpos  = agent_data.startpos;
+                        }
+                        return new XmlRpcResponse();
+                    });
                httpServer.AddRestHandler("GET", "/simstatus/",
                    delegate(string request, string path, string param)
                    {
diff --git a/OpenSim.RegionServer/SimClient.cs b/OpenSim.RegionServer/SimClient.cs
index 083ca68..52074b5 100644
--- a/OpenSim.RegionServer/SimClient.cs
+++ b/OpenSim.RegionServer/SimClient.cs
@@ -144,19 +144,19 @@ namespace OpenSim
            if(avatarpos.X<0) {
                neighbourx-=1;
-                newpos.X=0;
+                newpos.X=254;
            }
            if(avatarpos.X>255) {
                neighbourx+=1;
-                newpos.X=255;
+                newpos.X=1;
            }
            if(avatarpos.Y<0) { 
                neighboury-=1;
-                newpos.Y=0;
+                newpos.Y=254;
            }
            if(avatarpos.Y>255) {
                neighbourx+=1;
-                newpos.Y=255;
+                newpos.Y=1;
            }
            OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimClient.cs:CrossSimBorder() - Crossing border to neighbouring sim at [" + neighbourx.ToString() + "," + neighboury.ToString() + "]");
@@ -166,6 +166,19 @@ namespace OpenSim
            XmlRpcResponse GridResp;
            foreach(Hashtable borderingSim in ((RemoteGridBase)m_gridServer).neighbours) {
                if(((string)borderingSim["region_locx"]).Equals(neighbourx.ToString()) && ((string)borderingSim["region_locy"]).Equals(neighboury.ToString())) {
+                        SimParams = new Hashtable();
+                        SimParams["firstname"] = this.ClientAvatar.firstname;
+                        SimParams["lastname"] = this.ClientAvatar.lastname;
+                        SimParams["circuit_code"] = this.CircuitCode.ToString();
+                        SimParams["pos_x"] = newpos.X.ToString();
+                        SimParams["pos_y"] = newpos.Y.ToString();
+                        SimParams["pos_z"] = newpos.Z.ToString();
+                        SendParams = new ArrayList();
+                        SendParams.Add(SimParams);
+                        GridReq = new XmlRpcRequest("agent_crossing", SendParams);
+                        GridResp = GridReq.Send("http://" + borderingSim["sim_ip"] + ":" + borderingSim["sim_port"], 3000);
                        CrossedRegionPacket NewSimPack = new CrossedRegionPacket();
                        NewSimPack.AgentData = new CrossedRegionPacket.AgentDataBlock();
                        NewSimPack.AgentData.AgentID=this.AgentID;
@@ -196,6 +209,8 @@ namespace OpenSim
                OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimClient.cs:UpgradeClient() - upgrading child to full agent");       
                this.m_child=false;
                this.m_world.RemoveViewerAgent(this);
+                this.startpos=((RemoteGridBase)m_gridServer).agentcircuits[CircuitCode].startpos;
+                ((RemoteGridBase)m_gridServer).agentcircuits[CircuitCode].child=false;
                this.InitNewClient();
        }
diff --git a/OpenSim.RegionServer/SimComms.cs b/OpenSim.RegionServer/SimComms.cs
new file mode 100644
index 0000000..a2b936b
--- /dev/null
+++ b/OpenSim.RegionServer/SimComms.cs
@@ -0,0 +1,437 @@
+/*
+Copyright (c) OpenSim project, http://osgrid.org/
+*
+* 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 <organization> 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 <copyright holder> ``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 <copyright holder> 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 libsecondlife;
+using libsecondlife.Packets;
+using Nwc.XmlRpc;
+using System.Net;
+using System.Net.Sockets;
+using System.IO;
+using System.Threading;
+using System.Timers;
+using OpenSim.Framework.Interfaces;
+using OpenSim.Framework.Assets;
+using OpenSim.Framework.Inventory;
+using OpenSim.Framework.Utilities;
+using OpenSim.world;
+using OpenSim.Assets;
+namespace OpenSim
+{
+    public delegate bool PacketMethod(SimComms remoteSim, Packet packet);
+    /// <summary>
+    /// Handles sim<->sim communications
+    /// Constructor takes a single Packet and authenticates everything
+    /// </summary>
+    public class SimComms
+    {
+        public LLUUID SimUUID;
+        public bool m_child;
+        public uint CircuitCode;
+        private UseCircuitCodePacket cirpack;
+        public Thread ClientThread;
+        public EndPoint simEP;
+        private BlockingQueue<QueItem> PacketQueue;
+        private Dictionary<uint, uint> PendingAcks = new Dictionary<uint, uint>();
+        private Dictionary<uint, Packet> NeedAck = new Dictionary<uint, Packet>();
+        private System.Timers.Timer AckTimer;
+        private uint Sequence = 0;
+        private object SequenceLock = new object();
+        private const int MAX_APPENDED_ACKS = 10;
+        private const int RESEND_TIMEOUT = 4000;
+        private const int MAX_SEQUENCE = 0xFFFFFF;
+        private bool debug = false;
+        private World m_world;
+        private Dictionary<uint, SimComms> m_simThreads;
+        private IGridServer m_gridServer;
+        private IUserServer m_userServer = null;
+        private OpenSimNetworkHandler m_application;
+        //private bool m_sandboxMode;   // I can think of no reason why we'd ever have this set in sandbox mode
+        protected static Dictionary<PacketType, PacketMethod> PacketHandlers = new Dictionary<PacketType, PacketMethod>(); //Global/static handlers for all sims
+        protected Dictionary<PacketType, PacketMethod> m_packetHandlers = new Dictionary<PacketType, PacketMethod>(); //local handlers for this instance 
+        public IUserServer UserServer
+        {
+            set
+            {
+                this.m_userServer = value;
+            }
+        }
+        public SimComms(EndPoint remoteEP, UseCircuitCodePacket initialcirpack, World world, Dictionary<uint, SimComms> simThreads, IGridServer gridServer, OpenSimNetworkHandler application)
+        {
+            m_world = world;
+            m_clientThreads = clientThreads;
+            m_gridServer = gridServer;
+            m_application = application;
+            OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimComms.cs - Started up new thread to handle incoming request");
+            cirpack = initialcirpack;
+            simEP = remoteEP;
+            PacketQueue = new BlockingQueue<QueItem>();
+            AckTimer = new System.Timers.Timer(500);
+            AckTimer.Elapsed += new ElapsedEventHandler(AckTimer_Elapsed);
+            AckTimer.Start();
+            this.RegisterLocalPacketHandlers();
+            ClientThread = new Thread(new ThreadStart(AuthUser));
+            ClientThread.IsBackground = true;
+            ClientThread.Start();
+        }
+        protected virtual void RegisterLocalPacketHandlers()
+        {
+/*            this.AddLocalPacketHandler(PacketType.LogoutRequest, this.Logout);
+            this.AddLocalPacketHandler(PacketType.AgentCachedTexture, this.AgentTextureCached);
+            this.AddLocalPacketHandler(PacketType.MultipleObjectUpdate, this.MultipleObjUpdate);*/
+        }
+        public static bool AddPacketHandler(PacketType packetType, PacketMethod handler)
+        {
+            bool result = false;
+            lock (PacketHandlers)
+            {
+                if (!PacketHandlers.ContainsKey(packetType))
+                {
+                    PacketHandlers.Add(packetType, handler);
+                    result = true;
+                }
+            }
+            return result;
+        }
+        public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler)
+        {
+            bool result = false;
+            lock (m_packetHandlers)
+            {
+                if (!m_packetHandlers.ContainsKey(packetType))
+                {
+                    m_packetHandlers.Add(packetType, handler);
+                    result = true;
+                }
+            }
+            return result;
+        }
+        protected virtual bool ProcessPacketMethod(Packet packet)
+        {
+            bool result = false;
+            bool found = false;
+            PacketMethod method;
+            if (m_packetHandlers.TryGetValue(packet.Type, out method))
+            {
+                //there is a local handler for this packet type
+                result = method(this, packet);
+            }
+            else
+            {
+                //there is not a local handler so see if there is a Global handler
+                lock (PacketHandlers)
+                {
+                    found = PacketHandlers.TryGetValue(packet.Type, out method);
+                }
+                if (found)
+                {
+                    result = method(this, packet);
+                }
+            }
+            return result;
+        }
+        private void ack_pack(Packet Pack)
+        {
+            if (Pack.Header.Reliable)
+            {
+                libsecondlife.Packets.PacketAckPacket ack_it = new PacketAckPacket();
+                ack_it.Packets = new PacketAckPacket.PacketsBlock[1];
+                ack_it.Packets[0] = new PacketAckPacket.PacketsBlock();
+                ack_it.Packets[0].ID = Pack.Header.Sequence;
+                ack_it.Header.Reliable = false;
+                OutPacket(ack_it);
+            }
+            /*
+            if (Pack.Header.Reliable)
+            {
+                lock (PendingAcks)
+                {
+                    uint sequence = (uint)Pack.Header.Sequence;
+                    if (!PendingAcks.ContainsKey(sequence)) { PendingAcks[sequence] = sequence; }
+                }
+            }*/
+        }
+        protected virtual void ProcessInPacket(Packet Pack)
+        {
+            ack_pack(Pack);
+            if (this.ProcessPacketMethod(Pack))
+            {
+                //there is a handler registered that handled this packet type 
+                return;
+            }
+            else
+            {
+                System.Text.Encoding _enc = System.Text.Encoding.ASCII;
+                switch (Pack.Type)
+                {
+                }
+            }
+        }
+        private void ResendUnacked()
+        {
+            int now = Environment.TickCount;
+            lock (NeedAck)
+            {
+                foreach (Packet packet in NeedAck.Values)
+                {
+                    if ((now - packet.TickCount > RESEND_TIMEOUT) && (!packet.Header.Resent))
+                    {
+                        OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Resending " + packet.Type.ToString() + " packet, " +
+                         (now - packet.TickCount) + "ms have passed");
+                        packet.Header.Resent = true;
+                        OutPacket(packet);
+                    }
+                }
+            }
+        }
+        private void SendAcks()
+        {
+            lock (PendingAcks)
+            {
+                if (PendingAcks.Count > 0)
+                {
+                    if (PendingAcks.Count > 250)
+                    {
+                        // FIXME: Handle the odd case where we have too many pending ACKs queued up
+                        OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Too many ACKs queued up!");
+                        return;
+                    }
+                    //OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Sending PacketAck");
+                    int i = 0;
+                    PacketAckPacket acks = new PacketAckPacket();
+                    acks.Packets = new PacketAckPacket.PacketsBlock[PendingAcks.Count];
+                    foreach (uint ack in PendingAcks.Values)
+                    {
+                        acks.Packets[i] = new PacketAckPacket.PacketsBlock();
+                        acks.Packets[i].ID = ack;
+                        i++;
+                    }
+                    acks.Header.Reliable = false;
+                    OutPacket(acks);
+                    PendingAcks.Clear();
+                }
+            }
+        }
+        private void AckTimer_Elapsed(object sender, ElapsedEventArgs ea)
+        {
+            SendAcks();
+            ResendUnacked();
+        }
+        protected virtual void ProcessOutPacket(Packet Pack)
+        {
+            // Keep track of when this packet was sent out
+            Pack.TickCount = Environment.TickCount;
+            if (!Pack.Header.Resent)
+            {
+                // Set the sequence number
+                lock (SequenceLock)
+                {
+                    if (Sequence >= MAX_SEQUENCE)
+                        Sequence = 1;
+                    else
+                        Sequence++;
+                    Pack.Header.Sequence = Sequence;
+                }
+                if (Pack.Header.Reliable)  //DIRTY HACK
+                {
+                    lock (NeedAck)
+                    {
+                        if (!NeedAck.ContainsKey(Pack.Header.Sequence))
+                        {
+                            NeedAck.Add(Pack.Header.Sequence, Pack);
+                        }
+                        else
+                        {
+                            //  Client.Log("Attempted to add a duplicate sequence number (" +
+                            //     packet.Header.Sequence + ") to the NeedAck dictionary for packet type " +
+                            //      packet.Type.ToString(), Helpers.LogLevel.Warning);
+                        }
+                    }
+                    // Don't append ACKs to resent packets, in case that's what was causing the
+                    // delivery to fail
+                    if (!Pack.Header.Resent)
+                    {
+                        // Append any ACKs that need to be sent out to this packet
+                        lock (PendingAcks)
+                        {
+                            if (PendingAcks.Count > 0 && PendingAcks.Count < MAX_APPENDED_ACKS &&
+                                Pack.Type != PacketType.PacketAck &&
+                                Pack.Type != PacketType.LogoutRequest)
+                            {
+                                Pack.Header.AckList = new uint[PendingAcks.Count];
+                                int i = 0;
+                                foreach (uint ack in PendingAcks.Values)
+                                {
+                                    Pack.Header.AckList[i] = ack;
+                                    i++;
+                                }
+                                PendingAcks.Clear();
+                                Pack.Header.AppendedAcks = true;
+                            }
+                        }
+                    }
+                }
+            }
+            byte[] ZeroOutBuffer = new byte[4096];
+            byte[] sendbuffer;
+            sendbuffer = Pack.ToBytes();
+            try
+            {
+                if (Pack.Header.Zerocoded)
+                {
+                    int packetsize = Helpers.ZeroEncode(sendbuffer, sendbuffer.Length, ZeroOutBuffer);
+                    m_application.SendPacketTo(ZeroOutBuffer, packetsize, SocketFlags.None, CircuitCode);//userEP);
+                }
+                else
+                {
+                    m_application.SendPacketTo(sendbuffer, sendbuffer.Length, SocketFlags.None, CircuitCode); //userEP);
+                }
+            }
+            catch (Exception)
+            {
+                OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimComms.cs:ProcessOutPacket() - WARNING: Socket exception occurred on connection " + simEP.ToString() + " - killing thread");
+                ClientThread.Abort();
+            }
+        }
+        public virtual void InPacket(Packet NewPack)
+        {
+            // Handle appended ACKs
+            if (NewPack.Header.AppendedAcks)
+            {
+                lock (NeedAck)
+                {
+                    foreach (uint ack in NewPack.Header.AckList)
+                    {
+                        NeedAck.Remove(ack);
+                    }
+                }
+            }
+            // Handle PacketAck packets
+            if (NewPack.Type == PacketType.PacketAck)
+            {
+                PacketAckPacket ackPacket = (PacketAckPacket)NewPack;
+                lock (NeedAck)
+                {
+                    foreach (PacketAckPacket.PacketsBlock block in ackPacket.Packets)
+                    {
+                        NeedAck.Remove(block.ID);
+                    }
+                }
+            }
+            else if ((NewPack.Type == PacketType.StartPingCheck))
+            {
+                //reply to pingcheck
+                libsecondlife.Packets.StartPingCheckPacket startPing = (libsecondlife.Packets.StartPingCheckPacket)NewPack;
+                libsecondlife.Packets.CompletePingCheckPacket endPing = new CompletePingCheckPacket();
+                endPing.PingID.PingID = startPing.PingID.PingID;
+                OutPacket(endPing);
+            }
+            else
+            {
+                QueItem item = new QueItem();
+                item.Packet = NewPack;
+                item.Incoming = true;
+                this.PacketQueue.Enqueue(item);
+            }
+        }
+        public virtual void OutPacket(Packet NewPack)
+        {
+            QueItem item = new QueItem();
+            item.Packet = NewPack;
+            item.Incoming = false;
+            this.PacketQueue.Enqueue(item);
+        }
+        protected virtual void ClientLoop()
+        {
+            OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimComms.cs:ClientLoop() - Entered loop");
+            while (true)
+            {
+                QueItem nextPacket = PacketQueue.Dequeue();
+                if (nextPacket.Incoming)
+                {
+                    //is a incoming packet
+                    ProcessInPacket(nextPacket.Packet);
+                }
+                else
+                {
+                    //is a out going packet
+                    ProcessOutPacket(nextPacket.Packet);
+                }
+            }
+        }
+    }
+}
author	gareth	2007-04-17 10:53:50 +0000
committer	gareth	2007-04-17 10:53:50 +0000
commit	3e86870f7f1eb3d90089d41f8669fbd22d2e50d4 (patch)
tree	5e04e36b7725227e95618933a2850898504a12fc
parent	Sim crossing now works (except for broken co-ordinates, resets to 0,0 - to be... (diff)
download	opensim-SC_OLD-3e86870f7f1eb3d90089d41f8669fbd22d2e50d4.zip opensim-SC_OLD-3e86870f7f1eb3d90089d41f8669fbd22d2e50d4.tar.gz opensim-SC_OLD-3e86870f7f1eb3d90089d41f8669fbd22d2e50d4.tar.bz2 opensim-SC_OLD-3e86870f7f1eb3d90089d41f8669fbd22d2e50d4.tar.xz

diff --git a/OpenSim.RegionServer/OpenSimMain.cs b/OpenSim.RegionServer/OpenSimMain.cs index 038c7e6..7f2032d 100644 --- a/OpenSim.RegionServer/OpenSimMain.cs +++ b/OpenSim.RegionServer/OpenSimMain.cs
@@ -222,6 +222,26 @@ namespace OpenSim
222		222
223	return new XmlRpcResponse();	223	return new XmlRpcResponse();
224	});	224	});
		225
		226	httpServer.AddXmlRPCHandler("agent_crossing",
		227	delegate(XmlRpcRequest request)
		228	{
		229	Hashtable requestData = (Hashtable)request.Params[0];
		230	AgentCircuitData agent_data = new AgentCircuitData();
		231	agent_data.firstname = (string)requestData["firstname"];
		232	agent_data.lastname = (string)requestData["lastname"];
		233	agent_data.circuitcode = Convert.ToUInt32(requestData["circuit_code"]);
		234	agent_data.startpos = new LLVector3(Single.Parse((string)requestData["pos_x"]),Single.Parse((string)requestData["pos_y"]),Single.Parse((string)requestData["pos_z"]));
		235
		236	if(((RemoteGridBase)gridServer).agentcircuits.ContainsKey((uint)agent_data.circuitcode)) {
		237	((RemoteGridBase)gridServer).agentcircuits[(uint)agent_data.circuitcode].firstname = agent_data.firstname;
		238	((RemoteGridBase)gridServer).agentcircuits[(uint)agent_data.circuitcode].lastname = agent_data.lastname;
		239	((RemoteGridBase)gridServer).agentcircuits[(uint)agent_data.circuitcode].startpos = agent_data.startpos;
		240	}
		241
		242	return new XmlRpcResponse();
		243	});
		244
225	httpServer.AddRestHandler("GET", "/simstatus/",	245	httpServer.AddRestHandler("GET", "/simstatus/",
226	delegate(string request, string path, string param)	246	delegate(string request, string path, string param)
227	{	247	{


diff --git a/OpenSim.RegionServer/SimClient.cs b/OpenSim.RegionServer/SimClient.cs index 083ca68..52074b5 100644 --- a/OpenSim.RegionServer/SimClient.cs +++ b/OpenSim.RegionServer/SimClient.cs
@@ -144,19 +144,19 @@ namespace OpenSim
144		144
145	if(avatarpos.X<0) {	145	if(avatarpos.X<0) {
146	neighbourx-=1;	146	neighbourx-=1;
147	newpos.X=0;	147	newpos.X=254;
148	}	148	}
149	if(avatarpos.X>255) {	149	if(avatarpos.X>255) {
150	neighbourx+=1;	150	neighbourx+=1;
151	newpos.X=255;	151	newpos.X=1;
152	}	152	}
153	if(avatarpos.Y<0) {	153	if(avatarpos.Y<0) {
154	neighboury-=1;	154	neighboury-=1;
155	newpos.Y=0;	155	newpos.Y=254;
156	}	156	}
157	if(avatarpos.Y>255) {	157	if(avatarpos.Y>255) {
158	neighbourx+=1;	158	neighbourx+=1;
159	newpos.Y=255;	159	newpos.Y=1;
160	}	160	}
161	OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimClient.cs:CrossSimBorder() - Crossing border to neighbouring sim at [" + neighbourx.ToString() + "," + neighboury.ToString() + "]");	161	OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimClient.cs:CrossSimBorder() - Crossing border to neighbouring sim at [" + neighbourx.ToString() + "," + neighboury.ToString() + "]");
162		162
@@ -166,6 +166,19 @@ namespace OpenSim
166	XmlRpcResponse GridResp;	166	XmlRpcResponse GridResp;
167	foreach(Hashtable borderingSim in ((RemoteGridBase)m_gridServer).neighbours) {	167	foreach(Hashtable borderingSim in ((RemoteGridBase)m_gridServer).neighbours) {
168	if(((string)borderingSim["region_locx"]).Equals(neighbourx.ToString()) && ((string)borderingSim["region_locy"]).Equals(neighboury.ToString())) {	168	if(((string)borderingSim["region_locx"]).Equals(neighbourx.ToString()) && ((string)borderingSim["region_locy"]).Equals(neighboury.ToString())) {
		169	SimParams = new Hashtable();
		170	SimParams["firstname"] = this.ClientAvatar.firstname;
		171	SimParams["lastname"] = this.ClientAvatar.lastname;
		172	SimParams["circuit_code"] = this.CircuitCode.ToString();
		173	SimParams["pos_x"] = newpos.X.ToString();
		174	SimParams["pos_y"] = newpos.Y.ToString();
		175	SimParams["pos_z"] = newpos.Z.ToString();
		176	SendParams = new ArrayList();
		177	SendParams.Add(SimParams);
		178
		179	GridReq = new XmlRpcRequest("agent_crossing", SendParams);
		180	GridResp = GridReq.Send("http://" + borderingSim["sim_ip"] + ":" + borderingSim["sim_port"], 3000);
		181
169	CrossedRegionPacket NewSimPack = new CrossedRegionPacket();	182	CrossedRegionPacket NewSimPack = new CrossedRegionPacket();
170	NewSimPack.AgentData = new CrossedRegionPacket.AgentDataBlock();	183	NewSimPack.AgentData = new CrossedRegionPacket.AgentDataBlock();
171	NewSimPack.AgentData.AgentID=this.AgentID;	184	NewSimPack.AgentData.AgentID=this.AgentID;
@@ -196,6 +209,8 @@ namespace OpenSim
196	OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimClient.cs:UpgradeClient() - upgrading child to full agent");	209	OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimClient.cs:UpgradeClient() - upgrading child to full agent");
197	this.m_child=false;	210	this.m_child=false;
198	this.m_world.RemoveViewerAgent(this);	211	this.m_world.RemoveViewerAgent(this);
		212	this.startpos=((RemoteGridBase)m_gridServer).agentcircuits[CircuitCode].startpos;
		213	((RemoteGridBase)m_gridServer).agentcircuits[CircuitCode].child=false;
199	this.InitNewClient();	214	this.InitNewClient();
200	}	215	}
201		216


diff --git a/OpenSim.RegionServer/SimComms.cs b/OpenSim.RegionServer/SimComms.cs new file mode 100644 index 0000000..a2b936b --- /dev/null +++ b/OpenSim.RegionServer/SimComms.cs
@@ -0,0 +1,437 @@
		1	/*
		2	Copyright (c) OpenSim project, http://osgrid.org/
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions are met:
		6	* * Redistributions of source code must retain the above copyright
		7	* notice, this list of conditions and the following disclaimer.
		8	* * Redistributions in binary form must reproduce the above copyright
		9	* notice, this list of conditions and the following disclaimer in the
		10	* documentation and/or other materials provided with the distribution.
		11	* * Neither the name of the <organization> nor the
		12	* names of its contributors may be used to endorse or promote products
		13	* derived from this software without specific prior written permission.
		14	*
		15	* THIS SOFTWARE IS PROVIDED BY <copyright holder> ``AS IS'' AND ANY
		16	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
		17	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
		18	* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
		19	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
		20	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
		21	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
		22	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		23	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		24	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		25	*/
		26
		27	using System;
		28	using System.Collections;
		29	using System.Collections.Generic;
		30	using libsecondlife;
		31	using libsecondlife.Packets;
		32	using Nwc.XmlRpc;
		33	using System.Net;
		34	using System.Net.Sockets;
		35	using System.IO;
		36	using System.Threading;
		37	using System.Timers;
		38	using OpenSim.Framework.Interfaces;
		39	using OpenSim.Framework.Assets;
		40	using OpenSim.Framework.Inventory;
		41	using OpenSim.Framework.Utilities;
		42	using OpenSim.world;
		43	using OpenSim.Assets;
		44
		45	namespace OpenSim
		46	{
		47	public delegate bool PacketMethod(SimComms remoteSim, Packet packet);
		48
		49	/// <summary>
		50	/// Handles sim<->sim communications
		51	/// Constructor takes a single Packet and authenticates everything
		52	/// </summary>
		53	public class SimComms
		54	{
		55	public LLUUID SimUUID;
		56	public bool m_child;
		57	public uint CircuitCode;
		58	private UseCircuitCodePacket cirpack;
		59	public Thread ClientThread;
		60	public EndPoint simEP;
		61	private BlockingQueue<QueItem> PacketQueue;
		62	private Dictionary<uint, uint> PendingAcks = new Dictionary<uint, uint>();
		63	private Dictionary<uint, Packet> NeedAck = new Dictionary<uint, Packet>();
		64	private System.Timers.Timer AckTimer;
		65	private uint Sequence = 0;
		66	private object SequenceLock = new object();
		67	private const int MAX_APPENDED_ACKS = 10;
		68	private const int RESEND_TIMEOUT = 4000;
		69	private const int MAX_SEQUENCE = 0xFFFFFF;
		70	private bool debug = false;
		71	private World m_world;
		72	private Dictionary<uint, SimComms> m_simThreads;
		73	private IGridServer m_gridServer;
		74	private IUserServer m_userServer = null;
		75	private OpenSimNetworkHandler m_application;
		76	//private bool m_sandboxMode; // I can think of no reason why we'd ever have this set in sandbox mode
		77
		78	protected static Dictionary<PacketType, PacketMethod> PacketHandlers = new Dictionary<PacketType, PacketMethod>(); //Global/static handlers for all sims
		79
		80	protected Dictionary<PacketType, PacketMethod> m_packetHandlers = new Dictionary<PacketType, PacketMethod>(); //local handlers for this instance
		81
		82	public IUserServer UserServer
		83	{
		84	set
		85	{
		86	this.m_userServer = value;
		87	}
		88	}
		89
		90	public SimComms(EndPoint remoteEP, UseCircuitCodePacket initialcirpack, World world, Dictionary<uint, SimComms> simThreads, IGridServer gridServer, OpenSimNetworkHandler application)
		91	{
		92	m_world = world;
		93	m_clientThreads = clientThreads;
		94	m_gridServer = gridServer;
		95	m_application = application;
		96
		97	OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimComms.cs - Started up new thread to handle incoming request");
		98	cirpack = initialcirpack;
		99	simEP = remoteEP;
		100
		101	PacketQueue = new BlockingQueue<QueItem>();
		102
		103	AckTimer = new System.Timers.Timer(500);
		104	AckTimer.Elapsed += new ElapsedEventHandler(AckTimer_Elapsed);
		105	AckTimer.Start();
		106
		107	this.RegisterLocalPacketHandlers();
		108
		109	ClientThread = new Thread(new ThreadStart(AuthUser));
		110	ClientThread.IsBackground = true;
		111	ClientThread.Start();
		112	}
		113
		114	protected virtual void RegisterLocalPacketHandlers()
		115	{
		116	/* this.AddLocalPacketHandler(PacketType.LogoutRequest, this.Logout);
		117	this.AddLocalPacketHandler(PacketType.AgentCachedTexture, this.AgentTextureCached);
		118	this.AddLocalPacketHandler(PacketType.MultipleObjectUpdate, this.MultipleObjUpdate);*/
		119	}
		120
		121	public static bool AddPacketHandler(PacketType packetType, PacketMethod handler)
		122	{
		123	bool result = false;
		124	lock (PacketHandlers)
		125	{
		126	if (!PacketHandlers.ContainsKey(packetType))
		127	{
		128	PacketHandlers.Add(packetType, handler);
		129	result = true;
		130	}
		131	}
		132	return result;
		133	}
		134
		135	public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler)
		136	{
		137	bool result = false;
		138	lock (m_packetHandlers)
		139	{
		140	if (!m_packetHandlers.ContainsKey(packetType))
		141	{
		142	m_packetHandlers.Add(packetType, handler);
		143	result = true;
		144	}
		145	}
		146	return result;
		147	}
		148
		149	protected virtual bool ProcessPacketMethod(Packet packet)
		150	{
		151	bool result = false;
		152	bool found = false;
		153	PacketMethod method;
		154	if (m_packetHandlers.TryGetValue(packet.Type, out method))
		155	{
		156	//there is a local handler for this packet type
		157	result = method(this, packet);
		158	}
		159	else
		160	{
		161	//there is not a local handler so see if there is a Global handler
		162	lock (PacketHandlers)
		163	{
		164	found = PacketHandlers.TryGetValue(packet.Type, out method);
		165	}
		166	if (found)
		167	{
		168	result = method(this, packet);
		169	}
		170	}
		171	return result;
		172	}
		173
		174	private void ack_pack(Packet Pack)
		175	{
		176	if (Pack.Header.Reliable)
		177	{
		178	libsecondlife.Packets.PacketAckPacket ack_it = new PacketAckPacket();
		179	ack_it.Packets = new PacketAckPacket.PacketsBlock[1];
		180	ack_it.Packets[0] = new PacketAckPacket.PacketsBlock();
		181	ack_it.Packets[0].ID = Pack.Header.Sequence;
		182	ack_it.Header.Reliable = false;
		183
		184	OutPacket(ack_it);
		185
		186	}
		187	/*
		188	if (Pack.Header.Reliable)
		189	{
		190	lock (PendingAcks)
		191	{
		192	uint sequence = (uint)Pack.Header.Sequence;
		193	if (!PendingAcks.ContainsKey(sequence)) { PendingAcks[sequence] = sequence; }
		194	}
		195	}*/
		196	}
		197
		198	protected virtual void ProcessInPacket(Packet Pack)
		199	{
		200	ack_pack(Pack);
		201
		202	if (this.ProcessPacketMethod(Pack))
		203	{
		204	//there is a handler registered that handled this packet type
		205	return;
		206	}
		207	else
		208	{
		209	System.Text.Encoding _enc = System.Text.Encoding.ASCII;
		210
		211	switch (Pack.Type)
		212	{
		213	}
		214	}
		215	}
		216
		217	private void ResendUnacked()
		218	{
		219	int now = Environment.TickCount;
		220
		221	lock (NeedAck)
		222	{
		223	foreach (Packet packet in NeedAck.Values)
		224	{
		225	if ((now - packet.TickCount > RESEND_TIMEOUT) && (!packet.Header.Resent))
		226	{
		227	OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Resending " + packet.Type.ToString() + " packet, " +
		228	(now - packet.TickCount) + "ms have passed");
		229
		230	packet.Header.Resent = true;
		231	OutPacket(packet);
		232	}
		233	}
		234	}
		235	}
		236
		237	private void SendAcks()
		238	{
		239	lock (PendingAcks)
		240	{
		241	if (PendingAcks.Count > 0)
		242	{
		243	if (PendingAcks.Count > 250)
		244	{
		245	// FIXME: Handle the odd case where we have too many pending ACKs queued up
		246	OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Too many ACKs queued up!");
		247	return;
		248	}
		249
		250	//OpenSim.Framework.Console.MainConsole.Instance.WriteLine("Sending PacketAck");
		251
		252
		253	int i = 0;
		254	PacketAckPacket acks = new PacketAckPacket();
		255	acks.Packets = new PacketAckPacket.PacketsBlock[PendingAcks.Count];
		256
		257	foreach (uint ack in PendingAcks.Values)
		258	{
		259	acks.Packets[i] = new PacketAckPacket.PacketsBlock();
		260	acks.Packets[i].ID = ack;
		261	i++;
		262	}
		263
		264	acks.Header.Reliable = false;
		265	OutPacket(acks);
		266
		267	PendingAcks.Clear();
		268	}
		269	}
		270	}
		271
		272	private void AckTimer_Elapsed(object sender, ElapsedEventArgs ea)
		273	{
		274	SendAcks();
		275	ResendUnacked();
		276	}
		277
		278	protected virtual void ProcessOutPacket(Packet Pack)
		279	{
		280
		281	// Keep track of when this packet was sent out
		282	Pack.TickCount = Environment.TickCount;
		283
		284	if (!Pack.Header.Resent)
		285	{
		286	// Set the sequence number
		287	lock (SequenceLock)
		288	{
		289	if (Sequence >= MAX_SEQUENCE)
		290	Sequence = 1;
		291	else
		292	Sequence++;
		293	Pack.Header.Sequence = Sequence;
		294	}
		295
		296	if (Pack.Header.Reliable) //DIRTY HACK
		297	{
		298	lock (NeedAck)
		299	{
		300	if (!NeedAck.ContainsKey(Pack.Header.Sequence))
		301	{
		302	NeedAck.Add(Pack.Header.Sequence, Pack);
		303	}
		304	else
		305	{
		306	// Client.Log("Attempted to add a duplicate sequence number (" +
		307	// packet.Header.Sequence + ") to the NeedAck dictionary for packet type " +
		308	// packet.Type.ToString(), Helpers.LogLevel.Warning);
		309	}
		310	}
		311
		312	// Don't append ACKs to resent packets, in case that's what was causing the
		313	// delivery to fail
		314	if (!Pack.Header.Resent)
		315	{
		316	// Append any ACKs that need to be sent out to this packet
		317	lock (PendingAcks)
		318	{
		319	if (PendingAcks.Count > 0 && PendingAcks.Count < MAX_APPENDED_ACKS &&
		320	Pack.Type != PacketType.PacketAck &&
		321	Pack.Type != PacketType.LogoutRequest)
		322	{
		323	Pack.Header.AckList = new uint[PendingAcks.Count];
		324	int i = 0;
		325
		326	foreach (uint ack in PendingAcks.Values)
		327	{
		328	Pack.Header.AckList[i] = ack;
		329	i++;
		330	}
		331
		332	PendingAcks.Clear();
		333	Pack.Header.AppendedAcks = true;
		334	}
		335	}
		336	}
		337	}
		338	}
		339
		340	byte[] ZeroOutBuffer = new byte[4096];
		341	byte[] sendbuffer;
		342	sendbuffer = Pack.ToBytes();
		343
		344	try
		345	{
		346	if (Pack.Header.Zerocoded)
		347	{
		348	int packetsize = Helpers.ZeroEncode(sendbuffer, sendbuffer.Length, ZeroOutBuffer);
		349	m_application.SendPacketTo(ZeroOutBuffer, packetsize, SocketFlags.None, CircuitCode);//userEP);
		350	}
		351	else
		352	{
		353	m_application.SendPacketTo(sendbuffer, sendbuffer.Length, SocketFlags.None, CircuitCode); //userEP);
		354	}
		355	}
		356	catch (Exception)
		357	{
		358	OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimComms.cs:ProcessOutPacket() - WARNING: Socket exception occurred on connection " + simEP.ToString() + " - killing thread");
		359	ClientThread.Abort();
		360	}
		361
		362	}
		363
		364	public virtual void InPacket(Packet NewPack)
		365	{
		366	// Handle appended ACKs
		367	if (NewPack.Header.AppendedAcks)
		368	{
		369	lock (NeedAck)
		370	{
		371	foreach (uint ack in NewPack.Header.AckList)
		372	{
		373	NeedAck.Remove(ack);
		374	}
		375	}
		376	}
		377
		378	// Handle PacketAck packets
		379	if (NewPack.Type == PacketType.PacketAck)
		380	{
		381	PacketAckPacket ackPacket = (PacketAckPacket)NewPack;
		382
		383	lock (NeedAck)
		384	{
		385	foreach (PacketAckPacket.PacketsBlock block in ackPacket.Packets)
		386	{
		387	NeedAck.Remove(block.ID);
		388	}
		389	}
		390	}
		391	else if ((NewPack.Type == PacketType.StartPingCheck))
		392	{
		393	//reply to pingcheck
		394	libsecondlife.Packets.StartPingCheckPacket startPing = (libsecondlife.Packets.StartPingCheckPacket)NewPack;
		395	libsecondlife.Packets.CompletePingCheckPacket endPing = new CompletePingCheckPacket();
		396	endPing.PingID.PingID = startPing.PingID.PingID;
		397	OutPacket(endPing);
		398	}
		399	else
		400	{
		401	QueItem item = new QueItem();
		402	item.Packet = NewPack;
		403	item.Incoming = true;
		404	this.PacketQueue.Enqueue(item);
		405	}
		406
		407	}
		408
		409	public virtual void OutPacket(Packet NewPack)
		410	{
		411	QueItem item = new QueItem();
		412	item.Packet = NewPack;
		413	item.Incoming = false;
		414	this.PacketQueue.Enqueue(item);
		415	}
		416
		417	protected virtual void ClientLoop()
		418	{
		419	OpenSim.Framework.Console.MainConsole.Instance.WriteLine("SimComms.cs:ClientLoop() - Entered loop");
		420	while (true)
		421	{
		422	QueItem nextPacket = PacketQueue.Dequeue();
		423	if (nextPacket.Incoming)
		424	{
		425	//is a incoming packet
		426	ProcessInPacket(nextPacket.Packet);
		427	}
		428	else
		429	{
		430	//is a out going packet
		431	ProcessOutPacket(nextPacket.Packet);
		432	}
		433	}
		434	}
		435
		436	}
		437	}