Merged 3Di code that provides scene and avatar serialization, and plugin support for region move/split/merge. See ThirdParty/3Di/README.txt. Unless the new modules are used there should be no noticeable changes when running OpenSim.

9 files changed, 2791 insertions, 0 deletions

diff --git a/ThirdParty/3Di/LoadBalancer/LoadBalancerPlugin.cs b/ThirdParty/3Di/LoadBalancer/LoadBalancerPlugin.cs
new file mode 100644
index 0000000..6812777
--- /dev/null
+++ b/ThirdParty/3Di/LoadBalancer/LoadBalancerPlugin.cs
@@ -0,0 +1,1101 @@
+/*
+* 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.IO;
+using System.Net;
+using System.Xml;
+using System.Text;
+using System.Xml.Serialization;
+using System.Net.Sockets;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Servers;
+using OpenSim.Region.Environment;
+using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ClientStack;
+
+using Nwc.XmlRpc;
+using Nini.Config;
+
+using Mono.Addins;
+
+using libsecondlife;
+using libsecondlife.Packets;
+
+[assembly:Addin]
+[assembly:AddinDependency ("OpenSim", "0.5")]
+
+namespace OpenSim.ApplicationPlugins.LoadBalancer
+{
+    [Extension("/OpenSim/Startup")]
+    public class LoadBalancerPlugin : IApplicationPlugin
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        private OpenSimMain simMain;
+        private BaseHttpServer commandServer;
+
+        private List<UDPServer> udpServers;
+        private List<RegionInfo> regionData;
+
+        private int proxyOffset;
+        private string proxyURL;
+        private SceneManager sceneManager;
+         private string serializeDir;
+
+        private TcpServer mTcpServer;
+        private TcpClient mTcpClient;
+
+        public void Initialise(OpenSimMain openSim)
+        {
+            m_log.Info("[BALANCER] "+"Entering Initialize()");
+
+             StartTcpServer();
+            ClientView.SynchronizeClient = new ClientView.SynchronizeClientHandler(SynchronizePackets);
+            AsynchronousSocketListener.PacketHandler = new AsynchronousSocketListener.PacketRecieveHandler(SynchronizePacketRecieve);
+
+            this.sceneManager = openSim.SceneManager;
+            this.udpServers = openSim.UdpServers;
+            this.regionData = openSim.RegionData;
+            this.simMain = openSim;
+            this.commandServer = openSim.HttpServer;
+
+            proxyOffset = Int32.Parse(openSim.ConfigSource.Configs["Network"].GetString("proxy_offset", "0"));
+            proxyURL = openSim.ConfigSource.Configs["Network"].GetString("proxy_url", "");
+            if(proxyURL.Length==0) return;
+
+            serializeDir = openSim.ConfigSource.Configs["Network"].GetString("serialize_dir", "/tmp/");
+
+            commandServer.AddXmlRPCHandler("SerializeRegion", SerializeRegion);
+            commandServer.AddXmlRPCHandler("DeserializeRegion_Move", DeserializeRegion_Move);
+            commandServer.AddXmlRPCHandler("DeserializeRegion_Clone", DeserializeRegion_Clone);
+            commandServer.AddXmlRPCHandler("TerminateRegion", TerminateRegion);
+
+            commandServer.AddXmlRPCHandler("SplitRegion", SplitRegion);
+            commandServer.AddXmlRPCHandler("MergeRegions", MergeRegions);
+            commandServer.AddXmlRPCHandler("UpdatePhysics", UpdatePhysics);
+            commandServer.AddXmlRPCHandler("GetStatus", GetStatus);
+
+            m_log.Info("[BALANCER] "+"Exiting Initialize()");
+        }
+
+        private void StartTcpServer()
+        {
+            Thread server_thread = new Thread(new ThreadStart( 
+                                                delegate {
+                                                        mTcpServer = new TcpServer(10001);
+                                                        mTcpServer.start();
+                                                }));
+            server_thread.Start();
+        }
+
+        public void Close()
+        {
+        }
+
+        private XmlRpcResponse GetStatus(XmlRpcRequest request)
+        {
+                        XmlRpcResponse response = new XmlRpcResponse();
+                        try
+            {
+                m_log.Info("[BALANCER] "+"Entering RegionStatus()");
+
+                int src_port = (int)request.Params[0];
+                    Scene scene = null;
+                    // try to get the scene object
+                                RegionInfo src_region = SearchRegionFromPortNum(src_port);
+                    if (sceneManager.TryGetScene(src_region.RegionID, out scene) == false)
+                    {
+                        m_log.Error("[BALANCER] "+"The Scene is not found");
+                                        return response;
+                    }
+                    // serialization of client's informations
+                List<ScenePresence> presences = scene.GetScenePresences();
+                                int get_scene_presence = presences.Count;
+                                int get_scene_presence_filter = 0;
+                                foreach (ScenePresence pre in presences)
+                {
+                    ClientView client = (ClientView) pre.ControllingClient;
+                    //if(pre.MovementFlag!=0 && client.PacketProcessingEnabled==true) {
+                                        if(client.PacketProcessingEnabled==true) {
+                                                get_scene_presence_filter++;
+                                        }
+                }
+                                List<ScenePresence> avatars = scene.GetAvatars();
+                                int get_avatar = avatars.Count;
+                                int get_avatar_filter = 0;
+                                string avatar_names = "";
+                                foreach (ScenePresence pre in avatars)
+                {
+                    ClientView client = (ClientView) pre.ControllingClient;
+                    //if(pre.MovementFlag!=0 && client.PacketProcessingEnabled==true) {
+                                        if(client.PacketProcessingEnabled==true) {
+                                                get_avatar_filter++;
+                                                avatar_names += pre.Firstname + " " + pre.Lastname + "; ";
+                                        }
+                }
+                                
+                                Hashtable responseData = new Hashtable();
+                    responseData["get_scene_presence_filter"] = get_scene_presence_filter;
+                                responseData["get_scene_presence"] = get_scene_presence;
+                    responseData["get_avatar_filter"] = get_avatar_filter;
+                                responseData["get_avatar"] = get_avatar;
+                                responseData["avatar_names"] = avatar_names;
+                    response.Value = responseData;
+
+                                m_log.Info("[BALANCER] "+"Exiting RegionStatus()");
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[BALANCER] "+e.ToString());
+                m_log.Error("[BALANCER] "+e.StackTrace);
+            }
+                        return response;
+        }
+
+        private XmlRpcResponse SerializeRegion(XmlRpcRequest request)
+        {
+                        try
+            {
+                m_log.Info("[BALANCER] "+"Entering SerializeRegion()");
+
+                string src_url = (string)request.Params[0];
+                int src_port = (int)request.Params[1];
+
+                SerializeRegion(src_url, src_port);
+
+                m_log.Info("[BALANCER] "+"Exiting SerializeRegion()");
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[BALANCER] "+e.ToString());
+                m_log.Error("[BALANCER] "+e.StackTrace);
+            }
+
+            return new XmlRpcResponse();
+        }
+
+        private XmlRpcResponse DeserializeRegion_Move(XmlRpcRequest request)
+        {
+            try
+            {
+                m_log.Info("[BALANCER] "+"Entering DeserializeRegion_Move()");
+
+                string src_url = (string)request.Params[0];
+                int src_port = (int)request.Params[1];
+                string dst_url = (string)request.Params[2];
+                int dst_port = (int)request.Params[3];
+
+                DeserializeRegion_Move(src_port, dst_port, src_url, dst_url);
+
+                m_log.Info("[BALANCER] "+"Exiting DeserializeRegion_Move()");
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[BALANCER] "+e.ToString());
+                m_log.Error("[BALANCER] "+e.StackTrace);
+            }
+
+            return new XmlRpcResponse();
+        }
+
+        private XmlRpcResponse DeserializeRegion_Clone(XmlRpcRequest request)
+        {
+            try
+            {
+                m_log.Info("[BALANCER] "+"Entering DeserializeRegion_Clone()");
+
+                string src_url = (string)request.Params[0];
+                int src_port = (int)request.Params[1];
+                string dst_url = (string)request.Params[2];
+                int dst_port = (int)request.Params[3];
+
+                DeserializeRegion_Clone(src_port, dst_port, src_url, dst_url);
+
+                m_log.Info("[BALANCER] "+"Exiting DeserializeRegion_Clone()");
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[BALANCER] "+e.ToString());
+                m_log.Error("[BALANCER] "+e.StackTrace);
+                throw e;
+            }
+
+            return new XmlRpcResponse();
+        }
+
+        private XmlRpcResponse TerminateRegion(XmlRpcRequest request)
+        {
+            try
+            {
+                m_log.Info("[BALANCER] "+"Entering TerminateRegion()");
+
+                int src_port = (int)request.Params[0];
+
+                // backgroud
+                WaitCallback callback = new WaitCallback(TerminateRegion);
+                ThreadPool.QueueUserWorkItem(callback, src_port);
+
+                m_log.Info("[BALANCER] "+"Exiting TerminateRegion()");
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[BALANCER] "+e.ToString());
+                m_log.Error("[BALANCER] "+e.StackTrace);
+            }
+
+            return new XmlRpcResponse();
+        }
+
+        // internal functions
+
+        private void SerializeRegion(string src_url, int src_port)
+        {
+            RegionInfo src_region = null;
+
+            //------------------------------------------
+            // Processing of origin region
+            //------------------------------------------
+
+            // search origin region
+            src_region = SearchRegionFromPortNum(src_port);
+
+            if (src_region == null)
+            {
+                m_log.Error("[BALANCER] "+"Region not found");
+                return;
+            }
+
+            simMain.ProxyCommand(src_region.proxyUrl, "BlockClientMessages", src_url, src_port + proxyOffset);
+
+            // serialization of origin region's data
+            SerializeRegion(src_region, serializeDir);
+        }
+
+        private void DeserializeRegion_Move(int src_port, int dst_port, string src_url, string dst_url)
+        {
+            RegionInfo dst_region = null;
+
+            //------------------------------------------
+            // Processing of destination region
+            //------------------------------------------
+
+            // import the source region's data
+            dst_region = DeserializeRegion(dst_port, true, serializeDir);
+
+            simMain.ProxyCommand(dst_region.proxyUrl, "ChangeRegion", src_port + proxyOffset, src_url, dst_port + proxyOffset, dst_url);
+            simMain.ProxyCommand(dst_region.proxyUrl, "UnblockClientMessages", dst_url, dst_port + proxyOffset);
+        }
+
+        private void DeserializeRegion_Clone(int src_port, int dst_port, string src_url, string dst_url)
+        {
+            RegionInfo dst_region = null;
+
+            //------------------------------------------
+            // Processing of destination region
+            //------------------------------------------
+
+            // import the source region's data
+            dst_region = DeserializeRegion(dst_port, false, serializeDir);
+
+            // Decide who is in charge for each section
+            int[] port = new int[] { src_port, dst_port };
+            string[] url = new string[] { "http://" + src_url + ":" + commandServer.Port, "http://" + dst_url + ":" + commandServer.Port };
+            for(int i=0; i<2; i++) simMain.XmlRpcCommand(url[i], "SplitRegion", i, 2, port[0], port[1], url[0], url[1]);
+
+            // Enable the proxy
+            simMain.ProxyCommand(dst_region.proxyUrl, "AddRegion", src_port + proxyOffset, src_url, dst_port + proxyOffset, dst_url);
+            simMain.ProxyCommand(dst_region.proxyUrl, "UnblockClientMessages", dst_url, dst_port + proxyOffset);
+        }
+
+        private void TerminateRegion(object param)
+        {
+            RegionInfo src_region = null;
+            int src_port = (int)param;
+
+            //------------------------------------------
+            // Processing of remove region
+            //------------------------------------------
+
+            // search origin region
+            src_region = SearchRegionFromPortNum(src_port);
+
+            if (src_region == null)
+            {
+                m_log.Error("[BALANCER] "+"Region not found");
+                return;
+            }
+
+            isSplit = false;
+
+            // remove client resources
+            RemoveAllClientResource(src_region);
+            // remove old region
+            RemoveRegion(src_region.RegionID, src_region.InternalEndPoint.Port);
+
+            m_log.Info("[BALANCER] "+"Region terminated");
+        }
+
+        private RegionInfo SearchRegionFromPortNum(int portnum)
+        {
+            RegionInfo result = null;
+
+            foreach (RegionInfo rinfo in regionData)
+            {
+                if (rinfo.InternalEndPoint.Port == portnum)
+                {
+//                    m_log.Info("BALANCER",
+//                            "Region found. Internal Port = {0}, Handle={1}",
+//                            rinfo.InternalEndPoint.Port, rinfo.RegionHandle);
+                    result = rinfo;
+                    break;
+                }
+            }
+
+            return result;
+        }
+
+        private UDPServer SearchUDPServerFromPortNum(int portnum)
+        {
+            return udpServers.Find( delegate(UDPServer server) { return (portnum + proxyOffset == ((IPEndPoint) server.Server.LocalEndPoint).Port); });
+        }
+
+        private void SerializeRegion(RegionInfo src_region, string export_dir)
+        {
+            Scene scene = null;
+            List<ScenePresence> presences;
+            string filename;
+            int i = 0;
+
+            // try to get the scene object
+            if (sceneManager.TryGetScene(src_region.RegionID, out scene) == false)
+            {
+                m_log.Error("[BALANCER] "+"The Scene is not found");
+                return;
+            }
+
+            // create export directory
+            DirectoryInfo dirinfo = new DirectoryInfo(export_dir);
+            if (!dirinfo.Exists)
+            {
+                dirinfo.Create();
+            }
+
+            // serialization of client's informations
+            presences = scene.GetScenePresences();
+
+            foreach (ScenePresence pre in presences)
+            {
+                SerializeClient(i, scene, pre, export_dir);
+                i++;
+            }
+
+            // serialization of region data
+            SearializableRegionInfo dst_region = new SearializableRegionInfo(src_region);
+
+            filename = export_dir + "RegionInfo_" + src_region.RegionID.ToString() + ".bin";
+            Util.SerializeToFile(filename, dst_region);
+
+            // backup current scene's entities
+            //scene.Backup();
+
+            m_log.InfoFormat("[BALANCER] "+"region serialization completed [{0}]",
+                    src_region.RegionID.ToString());
+        }
+
+        private void SerializeClient(int idx, Scene scene, ScenePresence pre, string export_dir)
+        {
+            string filename;
+            IClientAPI controller = null;
+
+            m_log.InfoFormat("[BALANCER] "+"agent id : {0}", pre.m_uuid);
+
+            uint[] circuits = scene.ClientManager.GetAllCircuits(pre.m_uuid);
+
+            foreach (uint code in circuits)
+            {
+                m_log.InfoFormat("[BALANCER] "+"circuit code : {0}", code);
+
+                if (scene.ClientManager.TryGetClient(code, out controller))
+                {
+                    ClientInfo info = controller.GetClientInfo();
+
+                    filename = export_dir + "ClientInfo-" + String.Format("{0:0000}", idx) + "_" + controller.CircuitCode.ToString() + ".bin";
+
+                    Util.SerializeToFile(filename, info);
+
+                    m_log.InfoFormat("[BALANCER] "+"client info serialized [filename={0}]", filename);
+                }
+            }
+
+            //filename = export_dir + "Presence_" + controller.AgentId.ToString() + ".bin";
+            filename = export_dir + "Presence_" + String.Format("{0:0000}", idx) + ".bin";
+
+            Util.SerializeToFile(filename, pre);
+
+            m_log.InfoFormat("[BALANCER] "+"scene presence serialized [filename={0}]", filename);
+        }
+
+        private RegionInfo DeserializeRegion(int dst_port, bool move_flag, string import_dir)
+        {
+            string[] files = null;
+            RegionInfo dst_region = null;
+
+            try
+            {
+                // deserialization of region data
+                files = Directory.GetFiles(import_dir, "RegionInfo_*.bin");
+
+                foreach (string filename in files)
+                {
+                    m_log.InfoFormat("[BALANCER] RegionInfo filename = [{0}]", filename);
+
+                    dst_region = new RegionInfo((SearializableRegionInfo)Util.DeserializeFromFile(filename));
+
+                    m_log.InfoFormat("[BALANCER] "+"RegionID = [{0}]", dst_region.RegionID.ToString());
+                    m_log.InfoFormat("[BALANCER] "+"RegionHandle = [{0}]", dst_region.RegionHandle);
+                    m_log.InfoFormat("[BALANCER] "+"ProxyUrl = [{0}]", dst_region.proxyUrl);
+                    m_log.InfoFormat("[BALANCER] "+"OriginRegionID = [{0}]", dst_region.originRegionID.ToString());
+
+                    CreateCloneRegion(dst_region, dst_port, true);
+
+                    File.Delete(filename);
+
+                    m_log.InfoFormat("[BALANCER] "+"region deserialized [{0}]", dst_region.RegionID);
+                }
+
+                // deserialization of client data
+                DeserializeClient(dst_region, import_dir);
+
+                m_log.InfoFormat("[BALANCER] "+"region deserialization completed [{0}]", 
+                        dst_region.ToString());
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[BALANCER] "+e.ToString());
+                m_log.Error("[BALANCER] "+e.StackTrace);
+                throw e;
+            }
+
+            return dst_region;
+        }
+
+        private void DeserializeClient(RegionInfo dst_region, string import_dir)
+        {
+            ScenePresence sp = null;
+            ClientInfo data = null;
+            Scene scene = null;
+            string[] files = null;
+            IClientAPI controller = null;
+            UDPServer udpserv = null;
+
+            if (sceneManager.TryGetScene(dst_region.RegionID, out scene))
+            {
+                // search udpserver
+                udpserv = SearchUDPServerFromPortNum(scene.RegionInfo.InternalEndPoint.Port);
+
+                // restore the scene presence
+/*
+                files = Directory.GetFiles(import_dir, "Presence_*.bin");
+                Array.Sort(files);
+                                
+                foreach (string filename in files)
+                {
+                    sp = (ScenePresence)Util.DeserializeFromFile(filename);
+                    Console.WriteLine("agent id = {0}", sp.m_uuid);
+
+                    scene.m_restorePresences.Add(sp.m_uuid, sp);
+                    File.Delete(filename);
+
+                    m_log.InfoFormat("[BALANCER] "+"scene presence deserialized [{0}]", sp.m_uuid);
+                }
+*/
+                for (int i = 0; ; i++)
+                {
+                    string filename = import_dir + "Presence_" + String.Format("{0:0000}", i) + ".bin";
+
+                    if (!File.Exists(filename))
+                    {
+                        break;
+                    }
+
+                    sp = (ScenePresence)Util.DeserializeFromFile(filename);
+                    Console.WriteLine("agent id = {0}", sp.m_uuid);
+
+                    scene.m_restorePresences.Add(sp.m_uuid, sp);
+                    File.Delete(filename);
+
+                    m_log.InfoFormat("[BALANCER] " + "scene presence deserialized [{0}]", sp.m_uuid);
+
+                    // restore the ClientView
+
+                    files = Directory.GetFiles(import_dir, "ClientInfo-" + String.Format("{0:0000}", i) + "_*.bin");
+
+                    foreach (string fname in files)
+                    {
+                        int start = fname.IndexOf('_');
+                        int end = fname.LastIndexOf('.');
+                        uint circuit_code = uint.Parse(fname.Substring(start + 1, end - start - 1));
+                        m_log.InfoFormat("[BALANCER] " + "client circuit code = {0}", circuit_code);
+
+                        data = (ClientInfo)Util.DeserializeFromFile(fname);
+
+                        AgentCircuitData agentdata = new AgentCircuitData(data.agentcircuit);
+                        scene.AuthenticateHandler.AddNewCircuit(circuit_code, agentdata);
+
+                        udpserv.RestoreClient(agentdata, data.userEP, data.proxyEP);
+
+                                                        // waiting for the scene-presense restored
+                                                    lock (scene.m_restorePresences)
+                                                    {
+                                                            Monitor.Wait(scene.m_restorePresences, 3000);
+                                                    }
+                        
+                              if (scene.ClientManager.TryGetClient(circuit_code, out controller))
+                                                        {
+                                    m_log.InfoFormat("[BALANCER] " + "get client [{0}]", circuit_code);
+                                    controller.SetClientInfo(data);
+                                }

+

+                        File.Delete(fname);
+
+                        m_log.InfoFormat("[BALANCER] " + "client info deserialized [{0}]", circuit_code);
+                    }
+
+                    // backup new scene's entities
+                    //scene.Backup();
+                }
+            }
+        }
+
+        private void CreateCloneRegion(RegionInfo dst_region, int dst_port, bool createID_flag)
+        {
+            if (createID_flag)
+            {
+                dst_region.RegionID = LLUUID.Random();
+            }
+
+            // change RegionInfo (memory only)
+            dst_region.InternalEndPoint.Port = dst_port;
+            dst_region.ExternalHostName = proxyURL.Split(new char[] { '/', ':' })[3];
+
+            // Create new region
+            simMain.CreateRegion(dst_region, false);
+        }
+
+        private void RemoveRegion(LLUUID regionID, int port)
+        {
+            Scene killScene;
+            if (sceneManager.TryGetScene(regionID, out killScene))
+            {
+                Console.WriteLine("scene found.");
+
+                if ((sceneManager.CurrentScene != null) 
+                        && (sceneManager.CurrentScene.RegionInfo.RegionID == killScene.RegionInfo.RegionID))
+                {
+                    sceneManager.TrySetCurrentScene("..");
+                }
+
+                m_log.Info("Removing region : " + killScene.RegionInfo.RegionName);
+                regionData.Remove(killScene.RegionInfo);
+                sceneManager.CloseScene(killScene);
+            }
+
+            // Shutting down the UDP server
+            UDPServer udpsvr = SearchUDPServerFromPortNum(port);
+
+            if (udpsvr != null)
+            {
+                udpsvr.Server.Close();
+                udpServers.Remove(udpsvr);
+            }
+        }        
+
+        private void RemoveAllClientResource(RegionInfo src_region)
+        {
+            Scene scene = null;
+            List<ScenePresence> presences;
+            IClientAPI controller = null;
+
+            // try to get the scene object
+            if (sceneManager.TryGetScene(src_region.RegionID, out scene) == false)
+            {
+                m_log.Error("[BALANCER] "+"The Scene is not found");
+                return;
+            }
+
+            // serialization of client's informations
+            presences = scene.GetScenePresences();
+
+            // remove all scene presences
+            foreach (ScenePresence pre in presences)
+            {
+                uint[] circuits = scene.ClientManager.GetAllCircuits(pre.m_uuid);
+
+                foreach (uint code in circuits)
+                {
+                    m_log.InfoFormat("[BALANCER] "+"circuit code : {0}", code);
+
+                    if (scene.ClientManager.TryGetClient(code, out controller))
+                    {
+                        // stopping clientview thread
+                        if (((ClientView)controller).PacketProcessingEnabled)
+                           {
+                            controller.Stop();
+                            ((ClientView)controller).PacketProcessingEnabled = false;
+                           }
+                        // teminateing clientview thread
+                        controller.Terminate();
+                        m_log.Info("[BALANCER] "+"client thread stopped");
+                    }
+                }
+
+                // remove scene presence
+                scene.RemoveClient(pre.m_uuid);
+            }
+        }
+
+        /*
+         * This section implements scene splitting and synchronization
+         */
+
+        private bool[] isLocalNeighbour;
+        private string[] sceneURL;
+        private int[] regionPortList;
+        private TcpClient[] tcpClientList;
+        private bool isSplit = false;
+
+        private XmlRpcResponse SplitRegion(XmlRpcRequest request)
+        {
+                        try
+                        {
+                    int myID = (int) request.Params[0];
+                    int numRegions = (int) request.Params[1];
+                    regionPortList = new int[numRegions];
+                    sceneURL = new string[numRegions];
+                    tcpClientList = new TcpClient[numRegions];
+
+                    for(int i=0; i<numRegions; i++)
+                        {
+                        regionPortList[i]=(int) request.Params[i+2];
+                        sceneURL[i]=(string) request.Params[i+2+numRegions];
+                        }
+
+                    string hostname;
+
+                    for(int i=0; i<numRegions; i++)
+                       {
+                                hostname = sceneURL[i].Split(new char[] { '/', ':' })[3];
+                         m_log.InfoFormat("[SPLITSCENE] "+"creating tcp client host:{0}", hostname);
+                                tcpClientList[i] = new TcpClient(hostname, 10001);
+                       }
+   
+                    bool isMaster = (myID == 0);
+
+                    isLocalNeighbour = new bool[numRegions];
+                    for(int i=0; i<numRegions; i++) isLocalNeighbour[i] = (sceneURL[i] == sceneURL[myID]);
+
+                    RegionInfo region = SearchRegionFromPortNum(regionPortList[myID]);
+
+                    //Console.WriteLine("\n === SplitRegion {0}\n", region.RegionID);
+
+                    Scene scene;
+                    if (sceneManager.TryGetScene(region.RegionID, out scene))
+                      {
+                        // Disable event updates, backups etc in the slave(s)
+                        if (isMaster) {
+                            scene.Region_Status = RegionStatus.Up;
+                           }
+                        else 
+                           {
+                            scene.Region_Status = RegionStatus.SlaveScene;
+                           }
+
+                        //Console.WriteLine("=== SplitRegion {0}: Scene found, status {1}", region.RegionID, scene.Region_Status);
+
+                        // Disabling half of the avatars in master, and the other half in slave
+
+                        int i = 0;
+                        List<ScenePresence> presences = scene.GetScenePresences();
+presences.Sort();
+                        foreach (ScenePresence pre in presences)
+                           {
+                            // Divide the presences evenly over the set of subscenes
+                            ClientView client = (ClientView) pre.ControllingClient;
+                            client.PacketProcessingEnabled = (( (i + myID) % sceneURL.Length) == 0);
+
+                            m_log.InfoFormat("[SPLITSCENE] === SplitRegion {0}: SP.PacketEnabled {1}", region.RegionID, client.PacketProcessingEnabled);
+
+                              if (!client.PacketProcessingEnabled)
+                               {
+                                // stopping clientview thread
+                                client.Stop();
+                               }
+
+                            ++i;
+                            }
+
+                        scene.splitID = myID;
+                        scene.SynchronizeScene = new Scene.SynchronizeSceneHandler(SynchronizeScenes);
+                        isSplit = true;
+                    }
+                    else
+                    {
+                        m_log.Error("[SPLITSCENE] "+String.Format("Scene not found {0}", region.RegionID));
+                    }
+                }
+                catch (Exception e)
+                {
+                        m_log.Error("[SPLITSCENE] "+e.ToString());
+                        m_log.Error("[SPLITSCENE] "+e.StackTrace);
+                }
+
+           return new XmlRpcResponse();
+        }
+
+        private XmlRpcResponse MergeRegions(XmlRpcRequest request)
+        {
+            // This should only be called for the master scene
+            try
+            {
+                m_log.Info("[BALANCER] "+"Entering MergeRegions()");
+
+                string src_url = (string) request.Params[0];
+                int src_port = (int) request.Params[1];
+            
+                    RegionInfo region = SearchRegionFromPortNum(src_port);
+                                                                                
+                    simMain.ProxyCommand(region.proxyUrl, "BlockClientMessages", src_url, src_port + proxyOffset);
+
+                    Scene scene;
+                    if (sceneManager.TryGetScene(region.RegionID, out scene))
+                    {
+                        isSplit = false;
+
+                        scene.SynchronizeScene = null;
+                        scene.Region_Status = RegionStatus.Up;
+
+                        List<ScenePresence> presences = scene.GetScenePresences();
+                        foreach (ScenePresence pre in presences)
+                        {
+                            ClientView client = (ClientView) pre.ControllingClient;
+                            if (!client.PacketProcessingEnabled)
+                            {
+                               client.Restart();
+                               client.PacketProcessingEnabled = true;
+                            }
+                        }
+                    }
+                                
+                                // Delete the slave scenes
+                                for(int i=1; i<sceneURL.Length; i++)
+                                {
+                                        string url = (sceneURL[i].Split('/')[2]).Split(':')[0]; // get URL part from EP
+                                        simMain.ProxyCommand(region.proxyUrl, "DeleteRegion", regionPortList[i] + proxyOffset, url);
+                                        Thread.Sleep(1000);
+                                        simMain.XmlRpcCommand(sceneURL[i], "TerminateRegion",  regionPortList[i]); // TODO: need + proxyOffset?                         
+                                }
+
+                    simMain.ProxyCommand(region.proxyUrl, "UnblockClientMessages", src_url, src_port + proxyOffset);                    
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[BALANCER] "+e.ToString());
+                m_log.Error("[BALANCER] "+e.StackTrace);
+                throw e;
+            }
+                        
+            return new XmlRpcResponse();
+        }
+
+        private XmlRpcResponse UpdatePhysics(XmlRpcRequest request)
+        {
+            // this callback receives physic scene updates from the other sub-scenes (in split mode)
+
+            int regionPort = (int) request.Params[0];
+            LLUUID scenePresenceID = new LLUUID((byte[]) request.Params[1], 0);
+            LLVector3 position = new LLVector3((byte[]) request.Params[2], 0);
+            LLVector3 velocity = new LLVector3((byte[]) request.Params[3], 0);
+            bool flying = (bool) request.Params[4];
+
+            LocalUpdatePhysics(regionPort, scenePresenceID, position, velocity, flying);
+
+            return new XmlRpcResponse();
+        }
+
+        private void LocalUpdatePhysics(int regionPort, LLUUID scenePresenceID, LLVector3 position, LLVector3 velocity, bool flying)
+        {
+            //m_log.Info("[SPLITSCENE] "+String.Format("UpdatePhysics called {0}", regionID));
+
+            //m_log.Info("[SPLITSCENE] "+"LocalUpdatePhysics [region port:{0}, client:{1}, position:{2}, velocity:{3}, flying:{4}]", 
+            //                                       regionPort, scenePresenceID.ToString(), position.ToString(), 
+            //                                       velocity.ToString(), flying);
+
+            RegionInfo region = SearchRegionFromPortNum(regionPort);
+
+            // Find and update the scene precense
+            Scene scene;
+            if (sceneManager.TryGetScene(region.RegionID, out scene))
+            {
+                ScenePresence pre = scene.GetScenePresences().Find(delegate(ScenePresence x) { return x.UUID == scenePresenceID; }); 
+
+                  if (pre == null)
+                  {
+                    m_log.ErrorFormat("[SPLITSCENE] [LocalUpdatePhysics] ScenePresence is missing... ({0})", scenePresenceID.ToString());
+                    return;
+                  }
+
+//                m_log.Info("[SPLITSCENE] "+"LocalUpdatePhysics [region:{0}, client:{1}]", 
+//                                                                             regionID.ToString(), pre.UUID.ToString());
+
+                pre.AbsolutePosition = position;// will set PhysicsActor.Position
+                pre.Velocity = velocity; // will set PhysicsActor.Velocity
+                pre.PhysicsActor.Flying = flying;
+            }
+        }
+
+        object padlock=new object();
+        private void SynchronizeScenes(Scene scene)
+        {
+            if (!isSplit)
+            {
+                return;
+            }
+
+            lock(padlock)
+            {
+                // Callback activated after a physics scene update
+//                int i = 0;
+                List<ScenePresence> presences = scene.GetScenePresences();
+                foreach (ScenePresence pre in presences)
+                {
+                    ClientView client = (ClientView) pre.ControllingClient;
+
+                    // Because data changes by the physics simulation when the client doesn't move, 
+                    // if MovementFlag is false, It is necessary to synchronize.
+                    //if(pre.MovementFlag!=0 && client.PacketProcessingEnabled==true) 
+                  if(client.PacketProcessingEnabled==true) 
+                    {
+                        //m_log.Info("[SPLITSCENE] "+String.Format("Client moving in {0} {1}", scene.RegionInfo.RegionID, pre.AbsolutePosition));
+
+                            for (int i = 0; i < sceneURL.Length; i++)
+                               {
+                                                if (i == scene.splitID)
+                                                {
+                                                        continue;
+                                                }
+                                   
+                                        if(isLocalNeighbour[i])
+                                        {
+                                   //m_log.Info("[SPLITSCENE] "+"Synchronize ScenePresence (Local) [region:{0}=>{1}, client:{2}]", 
+                                   //                                             scene.RegionInfo.RegionID, regionPortList[i], pre.UUID.ToString());
+                                            LocalUpdatePhysics(regionPortList[i], pre.UUID, pre.AbsolutePosition, pre.Velocity, pre.PhysicsActor.Flying);
+                                        }
+                                        else
+                                        {
+                                   //m_log.Info("[SPLITSCENE] "+"Synchronize ScenePresence (Remote) [region port:{0}, client:{1}, position:{2}, velocity:{3}, flying:{4}]", 
+                                   //                                   regionPortList[i], pre.UUID.ToString(), pre.AbsolutePosition.ToString(), 
+                                   //                                   pre.Velocity.ToString(), pre.PhysicsActor.Flying);
+
+
+                                            simMain.XmlRpcCommand(sceneURL[i], "UpdatePhysics", 
+                                                        regionPortList[i], pre.UUID.GetBytes(),
+                                                        pre.AbsolutePosition.GetBytes(), pre.Velocity.GetBytes(),
+                                                        pre.PhysicsActor.Flying);
+
+/*
+                                        byte[] buff = new byte[12+12+1];
+
+                                    Buffer.BlockCopy(pre.AbsolutePosition.GetBytes(), 0, buff, 0, 12); 
+                                    Buffer.BlockCopy(pre.Velocity.GetBytes(), 0, buff, 12, 12); 
+                                    buff[24] = (byte)((pre.PhysicsActor.Flying)?1:0);
+
+                                                // create header
+                                                        InternalPacketHeader header = new InternalPacketHeader();
+
+                                  header.type = 1;
+                                  header.throttlePacketType = 0;
+                                  header.numbytes = buff.Length;
+                                  header.agent_id = pre.UUID.UUID;
+                                  header.region_port = regionPortList[i];
+
+                                                //Send
+                                                tcpClientList[i].send(header, buff);
+*/
+                                }
+                                        }
+                    }
+//                    ++i;
+                }
+            }
+        }
+
+        public bool SynchronizePackets(IScene scene, Packet packet, LLUUID agentID, ThrottleOutPacketType throttlePacketType)
+        {
+            if (!isSplit)
+            {
+                return false;
+            }
+
+           Scene localScene = (Scene)scene;
+
+                for (int i = 0; i < sceneURL.Length; i++)
+                {
+                        if (i == localScene.splitID)
+                        {
+                                continue;
+                        }
+                                   
+              if(isLocalNeighbour[i])
+                {
+                   //m_log.Info("[SPLITSCENE] "+"Synchronize Packet (Local) [type:{0}, client:{1}]", 
+                                          //                            packet.Type.ToString(), agentID.ToString());
+                            LocalUpdatePacket(regionPortList[i], agentID, packet, throttlePacketType);
+                }
+              else
+                {
+                  //m_log.Info("[SPLITSCENE] "+"Synchronize Packet (Remote) [type:{0}, client:{1}]", 
+                                        //                                                      packet.Type.ToString(), agentID.ToString());
+                                // to bytes
+                                byte[] buff = packet.ToBytes();
+
+                                // create header
+                                        InternalPacketHeader header = new InternalPacketHeader();
+
+                  header.type = 0;
+                  header.throttlePacketType = (int)throttlePacketType;
+                  header.numbytes = buff.Length;
+                  header.agent_id = agentID.UUID;
+                  header.region_port = regionPortList[i];
+
+                                //Send
+                                tcpClientList[i].send(header, buff);
+
+                                PacketPool.Instance.ReturnPacket(packet);
+                }
+            }
+
+            return true;
+        }
+
+        private void LocalUpdatePacket(int regionPort, LLUUID agentID, Packet packet, ThrottleOutPacketType throttlePacketType)
+        {
+            Scene scene;
+
+            RegionInfo region = SearchRegionFromPortNum(regionPort);
+
+//            m_log.Info("[SPLITSCENE] "+"LocalUpdatePacket [region port:{0}, client:{1}, packet type:{2}]", 
+//                                                          regionPort, agentID.ToString(), packet.GetType().ToString());
+
+            if (sceneManager.TryGetScene(region.RegionID, out scene))
+            {
+                ScenePresence pre = scene.GetScenePresences().Find(delegate(ScenePresence x) { return x.UUID == agentID; }); 
+
+                  if (pre == null)
+                  {
+                    m_log.ErrorFormat("[SPLITSCENE] [LocalUpdatePacket] ScenePresence is missing... ({0})", agentID.ToString());
+                    return;
+                  }
+
+                        if (((ClientView)pre.ControllingClient).PacketProcessingEnabled==true)
+                        {
+                                pre.ControllingClient.OutPacket(packet, throttlePacketType);
+                        }
+                        else
+                        {
+                                PacketPool.Instance.ReturnPacket(packet);
+                        }
+            }
+        }
+
+        public void SynchronizePacketRecieve(InternalPacketHeader header, byte[] buff)
+        {
+//            m_log.Info("[SPLITSCENE] "+"entering SynchronizePacketRecieve[type={0}]", header.type);
+
+            if (!isSplit)
+            {
+                return;
+            }
+
+            switch (header.type)
+            {
+                case 0:
+
+                    Packet packet = null;
+                    byte[] zero = new byte[3000];
+                    int packetEnd = 0;
+
+                    // deserialize packet
+                    packetEnd = buff.Length - 1;
+//                    packetEnd = buff.Length;
+
+                    try
+                     {
+                        //m_log.Info("[SPLITSCENE] "+"PacketPool.Instance : {0}", (PacketPool.Instance == null)?"null":"not null");
+                        //m_log.Info("[SPLITSCENE] "+"buff length={0}", buff.Length);
+
+                        packet = PacketPool.Instance.GetPacket(buff, ref packetEnd, zero);
+
+                        LocalUpdatePacket(header.region_port, new LLUUID(header.agent_id), 
+                                        packet, (ThrottleOutPacketType)header.throttlePacketType);
+                     }
+                    catch (Exception e)
+                     {
+                        m_log.Error("[SPLITSCENE] "+e.ToString());
+                        m_log.Error("[SPLITSCENE] "+e.StackTrace);
+                     }
+
+                  break;
+
+                case 1:
+
+                    int regionPort = header.region_port;
+                    LLUUID scenePresenceID = new LLUUID(header.agent_id);
+                    LLVector3 position = new LLVector3(buff, 0);
+                    LLVector3 velocity = new LLVector3(buff, 12);
+                    bool flying = ((buff[24] == (byte)1)?true:false);
+
+                    LocalUpdatePhysics(regionPort, scenePresenceID, position, velocity, flying);
+
+                    break;
+
+                default:
+                    m_log.Info("[SPLITSCENE] "+"Invalid type");
+                    break;
+            }
+
+//            m_log.Info("[SPLITSCENE] "+"exiting SynchronizePacketRecieve");
+        }
+    }
+}
diff --git a/ThirdParty/3Di/LoadBalancer/TcpClient.cs b/ThirdParty/3Di/LoadBalancer/TcpClient.cs
new file mode 100644
index 0000000..9f62d33
--- /dev/null
+++ b/ThirdParty/3Di/LoadBalancer/TcpClient.cs
@@ -0,0 +1,240 @@
+/*
+* 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.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using System.Text;
+using System.Runtime.Serialization.Formatters.Binary;
+
+namespace OpenSim.ApplicationPlugins.LoadBalancer {
+        public class AsynchronousClient {
+            private static ManualResetEvent connectDone = new ManualResetEvent(false);
+            private static ManualResetEvent sendDone = new ManualResetEvent(false);
+            private static ManualResetEvent receiveDone = new ManualResetEvent(false);
+            private static String response = String.Empty;
+
+            public static Socket StartClient(string hostname, int port) {
+                try {
+                    IPHostEntry ipHostInfo = Dns.GetHostEntry(hostname);
+                    IPAddress ipAddress = ipHostInfo.AddressList[0];
+                    IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
+
+                                Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+                                client.BeginConnect( remoteEP, new AsyncCallback(ConnectCallback), client);
+                    connectDone.WaitOne();
+                                /*
+                    Send(client,"This is a test<EOF>");
+                    sendDone.WaitOne();
+                    Receive(client);
+                    receiveDone.WaitOne();
+                    client.Shutdown(SocketShutdown.Both);
+                    client.Close();
+                                 */
+                                return client;
+                        } catch (Exception e) {
+                    Console.WriteLine(e.ToString());
+                                throw new Exception("socket error !!");
+                        }
+            }
+
+            private static void ConnectCallback(IAsyncResult ar) {
+                try {
+                    Socket client = (Socket) ar.AsyncState;
+                                client.EndConnect(ar);
+                    Console.WriteLine("Socket connected to {0}", client.RemoteEndPoint.ToString());
+                    connectDone.Set();
+                } catch (Exception e) {
+                    Console.WriteLine(e.ToString());
+                }
+            }
+
+/*
+            public static void Receive(Socket client) {
+                try {
+                    StateObject state = new StateObject();
+                    state.workSocket = client;
+                    client.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
+                } catch (Exception e) {
+                    Console.WriteLine(e.ToString());
+                }
+            }
+
+            private static void ReceiveCallback( IAsyncResult ar ) {
+                try {
+                    StateObject state = (StateObject) ar.AsyncState;
+                    Socket client = state.workSocket;
+
+                                int bytesRead = client.EndReceive(ar);
+                    if (bytesRead > 0) {
+                                        state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead));
+                        client.BeginReceive(state.buffer,0,StateObject.BufferSize,0, new AsyncCallback(ReceiveCallback), state);
+                    } else {
+                        if (state.sb.Length > 1) {
+                            response = state.sb.ToString();
+                        }
+                        receiveDone.Set();
+                    }
+                } catch (Exception e) {
+                    Console.WriteLine(e.ToString());
+                }
+            }
+*/
+            public static void Send(Socket client, byte[] byteData) {
+                client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client);
+            }
+
+            private static void SendCallback(IAsyncResult ar) {
+                try {
+                    Socket client = (Socket) ar.AsyncState;
+                    int bytesSent = client.EndSend(ar);
+                    //Console.WriteLine("Sent {0} bytes to server.", bytesSent);
+                    sendDone.Set();
+                } catch (Exception e) {
+                    Console.WriteLine(e.ToString());
+                }
+            }
+        }
+
+public class InternalPacketHeader
+{
+        private byte[] buffer = new byte[32];
+        public int      type;
+        public int      throttlePacketType;
+        public int      numbytes;
+        public Guid     agent_id;
+        public int      region_port;
+
+        public void FromBytes(byte[] bytes)
+    {
+                int i = 0; // offset
+                try
+        {
+                        this.type = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
+                        this.throttlePacketType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
+                        this.numbytes = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
+                        this.agent_id = new Guid(
+                bytes[i++] | (bytes[i++] << 8) | (bytes[i++] << 16) | bytes[i++] << 24,
+                (short)(bytes[i++] | (bytes[i++] << 8)),
+                (short)(bytes[i++] | (bytes[i++] << 8)),
+                bytes[i++], bytes[i++], bytes[i++], bytes[i++],
+                bytes[i++], bytes[i++], bytes[i++], bytes[i++]);
+                        this.region_port = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
+        }
+        catch (Exception)
+        {
+            throw new Exception("bad format!!!");
+        }
+    }
+
+        public byte[] ToBytes()
+    {
+                int i = 0;
+                this.buffer[i++] = (byte)(this.type % 256);
+        this.buffer[i++] = (byte)((this.type >> 8) % 256);
+        this.buffer[i++] = (byte)((this.type >> 16) % 256);
+        this.buffer[i++] = (byte)((this.type >> 24) % 256);
+
+                this.buffer[i++] = (byte)(this.throttlePacketType % 256);
+        this.buffer[i++] = (byte)((this.throttlePacketType >> 8) % 256);
+        this.buffer[i++] = (byte)((this.throttlePacketType >> 16) % 256);
+        this.buffer[i++] = (byte)((this.throttlePacketType >> 24) % 256);
+
+                this.buffer[i++] = (byte)(this.numbytes % 256);
+        this.buffer[i++] = (byte)((this.numbytes >> 8) % 256);
+        this.buffer[i++] = (byte)((this.numbytes >> 16) % 256);
+        this.buffer[i++] = (byte)((this.numbytes >> 24) % 256);
+
+                // no endian care
+                Buffer.BlockCopy(agent_id.ToByteArray(), 0, this.buffer, i, 16); i += 16;
+
+                this.buffer[i++] = (byte)(this.region_port % 256);
+        this.buffer[i++] = (byte)((this.region_port >> 8) % 256);
+        this.buffer[i++] = (byte)((this.region_port >> 16) % 256);
+        this.buffer[i++] = (byte)((this.region_port >> 24) % 256);
+
+                return this.buffer;
+        }
+}
+        public class TcpClient {
+
+                public static int internalPacketHeaderSize = 4*4 + 16*1;
+
+                private string mHostname;
+                private int mPort;
+                private Socket mConnection;
+                public TcpClient(string hostname, int port) {
+                        this.mHostname = hostname;
+                        this.mPort = port;
+                        this.mConnection = null;
+                }
+                public void connect() {
+                        this.mConnection = AsynchronousClient.StartClient(mHostname, mPort);
+                }
+/*
+                public void recevie() {
+                        if (mConnection == null) {
+                                throw new Exception("client not initialized");
+                        }
+                        try
+                        {
+                                AsynchronousClient.Receive(this.mConnection);
+                        }
+                        catch (Exception e)
+                        {
+                            Console.WriteLine(e.ToString());
+                                mConnection = null;
+                        }
+                }
+*/
+                public void send(InternalPacketHeader header, byte[] packet) {
+
+           lock (this)
+            {
+
+                        if (mConnection == null) {
+//                              throw new Exception("client not initialized");
+                                connect();
+                        }
+
+                        AsynchronousClient.Send(this.mConnection, header.ToBytes());
+
+/*
+for (int i = 0; i < 10; i++)
+{
+    Console.Write(packet[i] + " ");
+}
+Console.WriteLine("");
+*/
+                        AsynchronousClient.Send(this.mConnection, packet);
+            }
+                }
+        }
+}
diff --git a/ThirdParty/3Di/LoadBalancer/TcpServer.cs b/ThirdParty/3Di/LoadBalancer/TcpServer.cs
new file mode 100644
index 0000000..ee8bcba
--- /dev/null
+++ b/ThirdParty/3Di/LoadBalancer/TcpServer.cs
@@ -0,0 +1,219 @@
+/*
+* 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.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Runtime.Serialization.Formatters.Binary;
+
+using OpenSim.Framework.Console;
+
+namespace OpenSim.ApplicationPlugins.LoadBalancer {
+
+        public class StateObject {
+            public Socket workSocket = null;
+            public const int BufferSize = 2048;
+            public byte[] buffer = new byte[BufferSize];
+                public MemoryStream ms_ptr = new MemoryStream();
+                public InternalPacketHeader header = null;
+        }
+
+        public class AsynchronousSocketListener {
+            public static string data = null;
+            public static ManualResetEvent allDone = new ManualResetEvent(false);
+
+#region KIRYU
+        public delegate void PacketRecieveHandler(InternalPacketHeader header, byte[] buff);
+        public static PacketRecieveHandler PacketHandler = null;
+#endregion
+
+            public AsynchronousSocketListener() { }
+
+            public static void StartListening(int port) {
+                IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
+                IPAddress ipAddress = ipHostInfo.AddressList[0];
+                IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);
+
+                        Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );
+                try {
+                    listener.Bind(localEndPoint);
+                    listener.Listen(100);
+                    while (true) {
+                        allDone.Reset();
+                        listener.BeginAccept( new AsyncCallback(AcceptCallback), listener );
+                        allDone.WaitOne();
+                    }
+                } catch (Exception e) {
+                    Console.WriteLine(e.ToString());
+                }
+                        /*
+                        Console.WriteLine("\nPress ENTER to continue...");
+                Console.Read();
+                         */
+            }
+
+            public static void AcceptCallback(IAsyncResult ar) {
+                allDone.Set();
+                        Socket listener = (Socket) ar.AsyncState;
+                Socket handler = listener.EndAccept(ar);
+                StateObject state = new StateObject();
+                state.workSocket = handler;
+                handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
+            }
+
+            public static void ReadCallback(IAsyncResult ar) {
+                String content = String.Empty;
+                StateObject state = (StateObject) ar.AsyncState;
+                Socket handler = state.workSocket;
+
+            try
+            {
+                                
+                                int bytesRead = handler.EndReceive(ar);
+                                
+                                //MainLog.Instance.Verbose("TCPSERVER", "Received packet [{0}]", bytesRead);
+                                
+                                if (bytesRead > 0) {
+                                        state.ms_ptr.Write(state.buffer, 0, bytesRead);
+                                }
+                                else
+                                {               
+                                        //MainLog.Instance.Verbose("TCPSERVER", "Connection terminated");
+                                        return;
+                                }
+
+                                long rest_size = state.ms_ptr.Length;
+                                long current_pos = 0;
+                                while (rest_size > TcpClient.internalPacketHeaderSize) {
+
+                                        if ((state.header == null) && (rest_size >= TcpClient.internalPacketHeaderSize))
+                        {
+                                                //MainLog.Instance.Verbose("TCPSERVER", "Processing header");
+
+                            // reading header
+                            state.header = new InternalPacketHeader();
+
+                                byte[] headerbytes = new byte[TcpClient.internalPacketHeaderSize];
+                            state.ms_ptr.Position = current_pos;
+                                state.ms_ptr.Read(headerbytes, 0, TcpClient.internalPacketHeaderSize);
+                                                state.ms_ptr.Seek(0, SeekOrigin.End);
+                                state.header.FromBytes(headerbytes);
+                                        }
+
+                                        if ((state.header != null) && (rest_size >= state.header.numbytes + TcpClient.internalPacketHeaderSize))
+                        {
+                                                //MainLog.Instance.Verbose("TCPSERVER", "Processing body");
+
+                            // reading body 
+                                byte[] packet = new byte[state.header.numbytes];
+                                                state.ms_ptr.Position = current_pos + TcpClient.internalPacketHeaderSize;
+                                state.ms_ptr.Read(packet, 0, state.header.numbytes);
+
+/*
+                                                for(int i=0; i<state.header.numbytes; i++) {
+                                                        System.Console.Write(packet[i] + " ");
+                                                }
+                                                System.Console.WriteLine();
+*/
+                                                
+                                                state.ms_ptr.Seek(0, SeekOrigin.End);                                                           
+                                // call loadbarancer function
+                                if (PacketHandler != null)
+                                {
+                                        //MainLog.Instance.Verbose("TCPSERVER", "calling PacketHandler");
+                                                        PacketHandler(state.header, packet);
+                                }
+                                else
+                                {
+                                        //MainLog.Instance.Verbose("TCPSERVER", "PacketHandler not found");
+                                }
+
+                                                int read_size = state.header.numbytes + TcpClient.internalPacketHeaderSize;
+                                                state.header = null;
+
+                                                rest_size -= read_size;
+                                                current_pos += read_size;
+
+                                                if (rest_size < TcpClient.internalPacketHeaderSize) {
+                                                        
+                                                        byte[] rest_bytes = new byte[rest_size];
+                                                        state.ms_ptr.Position = read_size;
+                                                        state.ms_ptr.Read(rest_bytes, 0, (int)rest_size);
+                                                        state.ms_ptr.Close();
+                                                        state.ms_ptr = new MemoryStream();
+                                                        state.ms_ptr.Write(rest_bytes, 0, (int)rest_size);
+                                                        break;
+                                                }
+                                        }
+
+                                } // while (true)
+
+                        }
+                        catch (Exception e)
+                        {
+                                //MainLog.Instance.Verbose("TCPSERVER", e.ToString());
+                                //MainLog.Instance.Verbose("TCPSERVER", e.StackTrace);
+                        }
+
+                        handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
+                }
+            
+            private static void Send(Socket handler, String data) {
+                byte[] byteData = Encoding.ASCII.GetBytes(data);
+                handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);
+            }
+
+            private static void SendCallback(IAsyncResult ar) {
+                try {
+                    Socket handler = (Socket) ar.AsyncState;
+                    int bytesSent = handler.EndSend(ar);
+                    //Console.WriteLine("Sent {0} bytes to client.", bytesSent);
+                                handler.Shutdown(SocketShutdown.Both);
+                    handler.Close();
+                } catch (Exception e) {
+                    Console.WriteLine(e.ToString());
+                }
+            }
+        }
+
+        public class TcpServer {
+                private int mPort = 11000;
+                public TcpServer() {
+                }
+                public TcpServer(int port) {
+                        mPort = port;
+                }
+                public void start() {
+                        AsynchronousSocketListener.StartListening(mPort);
+                }
+        }
+}
+
diff --git a/ThirdParty/3Di/README.txt b/ThirdParty/3Di/README.txt
new file mode 100644
index 0000000..fd7980b
--- /dev/null
+++ b/ThirdParty/3Di/README.txt
@@ -0,0 +1,82 @@
+INTRODUCTION
+
+This folder contains code that implement:
+
+1. Dynamic load balancing
+
+OpenSim is allowing many regions to share a region server, but the optimal
+number of regions on each server depends on the load of each region, something
+which may change as time goes on. 3Di is working on a load balancer that
+allows the current load to be monitored and regions to be reassigned without
+requiring the servers to be restarted. To move a region, its state is
+serialized, and a new clone is created on the target server using this
+stream. The old region is then destroyed and the client viewer updated to use
+the new region address.
+
+2. Region splitting
+
+Currently each region can hold only a small number of avatars.  To allow more
+avatars in each region, 3Di has implemented region splitting, in which several
+copies of a given region can be distributed across the region servers. Each
+sub-region updates a fraction of the avatars, and sends state updates to the
+other sub-regions.
+
+IMPLEMENTATION
+
+The code is organised as follows:
+
+* LoadBalancer: communicates with other region servers and creates/destroys
+regions on command
+* RegionMonitor/MonitorGUI: provides a browser GUI, showing the state of the
+grid, and provides buttons for controlling region movement, splitting, and
+merging.
+* RegionMonitor/ServerPlugin: this is a region server plugin which 
+communicates with the load balancer GUI to provide information
+on the identity and status of the regions on the grid
+* RegionProxy: maps messages from a clients to the true location of a region.
+
+USAGE
+
+In order to use these additions the following lines have to be added to
+OpenSim.ini:
+
+proxy_offset = -1000
+proxy_url = http://10.8.1.50:9001
+serialize_dir = /mnt/temp/
+
+If defined, proxy_offset defines how to calculate the true region port, e.g.
+if the XML defines the port as 9000 the actual port is 8000 if proxy_offset 
+is -1000. The RegionProxy module will open a port at 9000 which the clients
+can connect to, and route all traffic from there to port 8000. This allows
+the region proxy to run on region server together with regions without
+blocking them by using the same port number.
+
+The proxy location is defined in proxy_url. When splitting, the region state
+is stored on a file in the folder specified in serialize_dir. This has to be
+a shared folder which both region servers involved in the split have access to.
+
+3. Monitor GUI
+
+RegionMonitor/MonitorGUI is used to view status of all the managed Region
+servers, and send "Move", "Split", "Merge" commands to a specified Regions
+server.
+
+MonitorGUI is a web-based application. You can access it through a web browser.
+Its back-end is written in perl. (CGI script)
+
+Pre-requierments (CentOS, Fedora)
+
+RPM package "perl-XML-RPC" and relevant packages.
+
+Installation
+
+1. Install Apache
+2. copy all the files undef "ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs" to
+"$APACHE_ROOT/htdocs"
+3. Configuration in "monitor.cgi"
+ * 10th line, set the value to your "monitor.cgi"'s location.
+ * 11th line, set the value to your Grid server.
+ * 12th line, set your region proxy port number here.
+   (ref. OpenSim.ini::NetWork::http_listener_port)
+* The code also works fine with mod_perl.
+
diff --git a/ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs/MonitorGUI/View.pm b/ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs/MonitorGUI/View.pm
new file mode 100644
index 0000000..bab462f
--- /dev/null
+++ b/ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs/MonitorGUI/View.pm
@@ -0,0 +1,214 @@
+package MonitorGUI::View;
+
+use strict;
+
+my @server_list;
+my $max_port;
+my $regions;
+
+sub screen_header {
+    return << "HEADER";
+<HTML>
+<HEAD>
+<STYLE TYPE="text/css">
+<!--
+a:link    {font-size: 12pt; text-decoration:none; color:#0000ff ;}
+a:visited {font-size: 12pt; text-decoration:none; color:#ff0000 ;}
+a:active  {font-size: 12pt; text-decoration:none; color:#00ff00 ;}
+a:hover   {font-size: 12pt; text-decoration:underline; color:#ff00ff ;}
+td        {font-size: 12pt;border:0;}
+th        {background-color:#000000; font-size: 12pt;border:0; color:#FFFFFF; }
+tr        {background-color:#FFFFFF; }
+b         {font-size: 12pt;}
+//table     {background-color:#000000; }
+-->
+</STYLE>    
+<META http-equiv="content-type" content="text/html;charset=UTF-8" />
+<META name="refresh" content="300" />
+<TITLE>Region Monitor GUI, 3Di</TITLE>
+</HEAD>
+<BODY>
+HEADER
+}
+
+sub screen_footer {
+    return << "FOOTER";
+</BODY>
+</HTML>
+FOOTER
+}
+
+sub html {
+        my $grid_info = shift;
+        my $regions_list = $grid_info->{"sim-profiles"};
+        $regions = undef;
+        foreach(@$regions_list) {
+                my $ip = $_->{sim_ip} || "UNKNOWN";
+                my $port = $_->{sim_port} || "UNKNOWN";
+                $regions->{$ip}->{$port} = $_;
+                if (!$regions->{max_port} || $regions->{max_port} < $port) {
+                        $regions->{max_port} = $port;
+                }
+        }
+        @server_list = keys %$regions;
+        $max_port = $regions->{max_port};
+        my $html = "";
+        foreach my $machine (@server_list) {
+                next if ($machine eq "max_port");
+                $html .= &_machine_view($machine, $regions->{$machine});
+        }
+        return $html;
+}
+
+sub _machine_view {
+        my ($ip, $info) = @_;
+        my $region_html = "";
+        foreach my $region (keys %$info) {
+                $region_html .= &_region_html($info->{$region});
+        }
+        my $html =<< "MACHINE_HTML";
+<h3>$ip</h3>
+$region_html
+<hr size=0 noshade /> 
+MACHINE_HTML
+}
+
+sub _region_html {
+        my $region_info = shift;
+        my $name = $region_info->{name} || "UNKNOWN";
+        my $x = $region_info->{x} || -1;
+        my $y = $region_info->{y} || -1;
+        my $ip = $region_info->{sim_ip} || "UNKNOWN";
+        my $port = $region_info->{sim_port} || "UNKNOWN";
+        my $get_scene_presence_filter = $region_info->{get_scene_presence_filter};
+        my $get_scene_presence = $region_info->{get_scene_presence};
+        my $get_avatar_filter = $region_info->{get_avatar_filter};
+        my $get_avatar = $region_info->{get_avatar};
+        my $avatar_names = $region_info->{avatar_names};
+        my $action_forms = &_action_forms($region_info);
+        my $html = <<"REGION_HTML";
+<strong>$name</strong><br/>
+$ip:$port | X: $x Y: $y<br/>
+<table border="0">
+<tr>
+<td>get_avatar</td>
+<td>$get_avatar</td>
+<td></td>
+</tr>
+<tr>
+<td>get_avatar_filter</td>
+<td>$get_avatar_filter</td>
+<td>$avatar_names</td>
+</tr>
+<tr>
+<td>get_scene_presence</td>
+<td>$get_scene_presence</td>
+<td></td>
+</tr>
+<tr>
+<td>get_scene_presence_filter</td>
+<td>$get_scene_presence_filter</td>
+<td></td>
+</tr>
+</table>
+$action_forms
+REGION_HTML
+        return $html;
+}
+
+sub _action_forms {
+        my $region_info = shift;
+        my $ip = $region_info->{sim_ip};
+        my $port = $region_info->{sim_port};
+        my $default_input_port = $max_port + 1;
+        my $move_to_options = "";
+        my $split_to_options = "";
+        my $merge_ip_options = "";
+        foreach(@server_list) {
+                next if ($_ eq "max_port");
+                $merge_ip_options .= "<option value=\"$_\">$_\n";
+                $split_to_options .= "<option value=\"$_\">$_\n";
+                #next if ($_ eq $ip);
+                $move_to_options .= "<option value=\"$_\">$_\n";
+        }
+        my $merge_port_options = "";
+        my $merge_disabled = "disabled";
+
+        foreach(keys %{$regions->{$ip}}) {
+                next if ($_ eq $port);
+                $merge_disabled = "";
+        }
+#       for(9000..$max_port) { # TODO :
+#               next if ($_ eq $port);
+#               $merge_port_options .= "<option value=\"$_\">$_\n";
+#       }
+        my %port = ();
+        foreach my $ip (keys %$regions) {
+                next if ($ip eq "max_port");
+                print STDERR "--" . $ip . "\n";
+                foreach my $region_port (keys %{$regions->{$ip}}) {
+                print STDERR "---" . $region_port . "\n";
+                        $port{$region_port} = 1;
+                }
+        }
+        foreach (keys %port) {
+                $merge_port_options .= "<option value=\"$_\">$_\n";
+                $merge_disabled = "";
+        }
+        return << "ACTION_FORMS";
+<table>
+<tr>
+<form method="POST">
+<td>
+<input type="hidden" name="A" value="move" />
+<input type="hidden" name="from_ip" value="$ip" />
+<input type="hidden" name="from_port" value="$port" />
+<input type="submit" value="Move to" />
+<select name="to_ip">
+$move_to_options
+</select>:
+<input type="text" name="to_port" size="5" value="$default_input_port"/>
+</td>
+</form>
+
+<td>
+&nbsp;&nbsp;|&nbsp;&nbsp;
+</td>
+
+<form method="POST">
+<td>
+<input type="hidden" name="A" value="split" />
+<input type="hidden" name="from_ip" value="$ip" />
+<input type="hidden" name="from_port" value="$port" />
+<input type="submit" value="Split to" />
+<select name="to_ip">
+$split_to_options
+</select>:
+<input type="text" name="to_port" size="5" value="$default_input_port"/>
+</td>
+</form>
+
+<td>
+&nbsp;&nbsp;|&nbsp;&nbsp;
+</td>
+
+<form method="POST">
+<td>
+<input type="hidden" name="A" value="merge" />
+<input type="hidden" name="from_ip" value="$ip" />
+<input type="hidden" name="master_port" value="$port" />
+<input type="submit" value="Merge" $merge_disabled />
+<select name="slave_ip" $merge_disabled>
+$merge_ip_options
+</select>
+<select name="slave_port" $merge_disabled>
+$merge_port_options
+</select>
+</td>
+</form>
+</tr>
+</table>
+ACTION_FORMS
+}
+
+1;
diff --git a/ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs/MyCGI.pm b/ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs/MyCGI.pm
new file mode 100644
index 0000000..1f232aa
--- /dev/null
+++ b/ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs/MyCGI.pm
@@ -0,0 +1,91 @@
+package MyCGI;
+
+use strict;
+use CGI;
+
+sub getParam {
+        my $cgi;
+        if ($ARGV[0]) {
+                $cgi = new CGI($ARGV[0]);
+        } else {
+                $cgi = new CGI;
+        }
+        my @param_names = $cgi->param();
+        my %param = ();
+        foreach (@param_names) {
+                $param{$_} = $cgi->param($_);
+        }
+        return \%param;
+}
+
+sub getCookie {
+        my $name = shift;
+        my $cookie_value = &CGI::cookie($name);
+        return &_parse($cookie_value);
+}
+
+sub outputHtml {
+        my ($charset, $html) = @_;
+        print &CGI::header(-charset => $charset);
+        print $html;
+}
+
+sub outputXml {
+        my ($charset, $xml) = @_;
+        print &CGI::header( -type => 'text/xml', -charset => $charset );
+        print $xml;
+}
+
+sub makeCookieValue {
+        my $param = shift;
+        my @data = ();
+        foreach(keys %$param) {
+                push(@data, $_ . "=" . $param->{$_});
+        }
+        return join("&", @data);
+}
+
+sub setCookie {
+        my $param = shift;
+        my $cookie = &CGI::cookie(
+                -name => $param->{name} || return,
+                -value => $param->{value},
+                -domain => $param->{domain},
+                -path => $param->{path},
+                -expires => $param->{expires},
+        );
+        return &CGI::header(-cookie => $cookie);
+}
+
+sub redirect {
+        my $dest = shift;
+        &CGI::redirect($dest);
+}
+
+sub urlEncode {
+        my $str = shift;
+        $str =~ s/([^\w ])/'%'.unpack('H2', $1)/eg;
+        $str =~ tr/ /+/;
+        return $str;
+}
+
+sub urlDecode {
+  my $str = shift;
+  $str =~ tr/+/ /;
+  $str =~ s/%([0-9A-Fa-f][0-9A-Fa-f])/pack('H2', $1)/eg;
+  return $str;
+}
+
+sub _parse {
+        my $value = shift;
+        my @pair = split(/&/, $value);
+        my %data = ();
+        foreach(@pair) {
+                my ($name, $value) = split(/=/, $_);
+                $data{$name} = $value;
+        }
+        return \%data;
+}
+
+1;
+
diff --git a/ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs/monitor.cgi b/ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs/monitor.cgi
new file mode 100644
index 0000000..a5f6445
--- /dev/null
+++ b/ThirdParty/3Di/RegionMonitor/MonitorGUI/htdocs/monitor.cgi
@@ -0,0 +1,202 @@
+#!/usr/bin/perl -w
+
+use strict;
+use Carp;
+use MyCGI;
+use XML::RPC;
+use MonitorGUI::View;
+
+use vars qw ($THIS_URL $GRID_SERVER_URL $DEFAULT_PROXY_PORT);
+$THIS_URL = "http://10.8.1.165/monitorgui/monitor.cgi";
+$GRID_SERVER_URL = "http://10.8.1.165/opensim/grid.cgi";
+$DEFAULT_PROXY_PORT = 9000;
+
+my %ACTIONS = (
+    # Region commands
+    move  => \&move_command,
+    split => \&split_command,
+    merge => \&merge_command,
+    # display commands
+    default => \&main_screen,
+    refresh => \&refresh,
+);
+
+# ##################
+# main
+my $param = &MyCGI::getParam;
+my $act = $param->{A} || "default";
+my $contents = "";
+if (!$ACTIONS{$act}) {
+    &gui_error("404 NOT FOUND");
+} else {
+    eval {
+                $ACTIONS{$act}->($param);
+    };
+    if ($@) {
+                &gui_error($@);
+    }
+}
+
+# #################
+# Region Commands
+sub move_command {
+    my $param = shift;
+        # from
+        my $from_ip = $param->{from_ip} || Carp::croak("not enough params (from_ip)");
+        my $from_port = $param->{from_port} || Carp::croak("not enough params (from_port)");
+        my $from_url = "http://" . $param->{from_ip} . ":" . $DEFAULT_PROXY_PORT;
+        # to
+        my $to_ip = $param->{to_ip} || Carp::croak("not enough params (to_ip)");
+        my $to_port = $param->{to_port} || Carp::croak("not enough params (to_port)");
+        my $to_url = "http://" . $param->{to_ip} . ":" . $DEFAULT_PROXY_PORT;
+        # commands
+        eval {
+                &OpenSim::Utility::XMLRPCCall_array($from_url, "SerializeRegion", [$from_ip, $from_port]);
+                &OpenSim::Utility::XMLRPCCall_array($to_url, "DeserializeRegion_Move", [$from_ip, $from_port, $to_ip, $to_port]);
+                &OpenSim::Utility::XMLRPCCall_array($from_url, "TerminateRegion", [$from_port]);
+        };                      
+        if ($@) {
+                print STDERR "Get Status Error: $@\n";
+        }
+
+        # client refresh
+    &redirect_refresh({wait=>5, force=>"$from_url|$to_url", msg=>"Move region $from_ip:$from_port from $from_url to $to_url"});
+}
+
+sub split_command {
+    my $param = shift;
+        # from
+        my $from_ip = $param->{from_ip} || Carp::croak("not enough params (from_ip)");
+        my $from_port = $param->{from_port} || Carp::croak("not enough params (from_port)");
+        my $from_url = "http://" . $param->{from_ip} . ":" . $DEFAULT_PROXY_PORT;
+        # to
+        my $to_ip = $param->{to_ip} || Carp::croak("not enough params (to_ip)");
+        my $to_port = $param->{to_port} || Carp::croak("not enough params (to_port)");
+        my $to_url = "http://" . $param->{to_ip} . ":" . $DEFAULT_PROXY_PORT;
+        # commands
+        eval {
+                &OpenSim::Utility::XMLRPCCall_array($from_url, "SerializeRegion", [$from_ip, $from_port]);
+                &OpenSim::Utility::XMLRPCCall_array($to_url, "DeserializeRegion_Clone", [$from_ip, $from_port, $to_ip, $to_port]);
+        };                      
+        if ($@) {
+                print STDERR "Get Status Error: $@\n";
+        }
+
+    &redirect_refresh({wait=>5, force=>"$from_url", msg=>"Split region $from_ip:$from_port"});
+}
+
+sub merge_command {
+    my $param = shift;
+        # from
+        my $from_ip = $param->{from_ip} || Carp::croak("not enough params (from_ip)");
+        my $url = "http://" . $param->{from_ip} . ":" . $DEFAULT_PROXY_PORT;
+        # ports
+        my $master_port = $param->{master_port} || Carp::croak("not enough params (master_port)");
+        my $slave_ip = $param->{slave_ip} || Carp::croak("not enough params (slave_ip)");
+        my $slave_port = $param->{slave_port} || Carp::croak("not enough params (slave_port)");
+        my $slave_url = "http://" . $param->{slave_ip} . ":" . $DEFAULT_PROXY_PORT;
+        # commands
+        eval {
+                &XMLRPCCall_array($url, "MergeRegions", [$from_ip, $master_port]);
+                &XMLRPCCall_array($slave_url, "TerminateRegion", [$slave_port]);
+        };
+        if ($@) {
+                print STDERR "Get Status Error: $@\n";
+        }
+        &redirect_refresh({wait=>5, force=>"$url", msg=>"Merge region $from_ip:$master_port, $slave_port"});
+}
+
+# #################
+# Display
+sub main_screen {
+    my %xml_rpc_param = (
+                # TODO: should be 0 - 65535 ?
+                xmin => 999, ymin => 999, xmax => 1010, ymax => 1010,
+        );
+        my $res_obj = undef; 
+    eval {
+                $res_obj = &XMLRPCCall($GRID_SERVER_URL, "map_block", \%xml_rpc_param);
+    };
+    if ($@) {
+                &gui_error("map_block Error: " . $@);
+    }
+        my %copy_obj = %$res_obj;
+        my $getstatus_failed = "<font color=\"red\">GetStatus Failed</font>";
+        my $regions_list = $res_obj->{"sim-profiles"};
+        foreach(@$regions_list) {
+                if ($_->{sim_ip} && $_->{sim_port}) {
+                        my $url = "http://" . $_->{sim_ip} . ":" . $DEFAULT_PROXY_PORT;
+                        my $port = $_->{sim_port};
+                        my $res = undef;
+                    eval {
+                                $res = &XMLRPCCall_array($url, "GetStatus", [$port]);
+                    };                  
+                    if ($@) {
+                        print STDERR "Get Status Error: $@\n";
+                    }
+                        $_->{get_scene_presence_filter} = $res ? $res->{get_scene_presence_filter} : $getstatus_failed;
+                        $_->{get_scene_presence} = $res ? $res->{get_scene_presence} : $getstatus_failed;
+                        $_->{get_avatar_filter} = $res ? $res->{get_avatar_filter} : $getstatus_failed;
+                        $_->{get_avatar} = $res ? $res->{get_avatar} : $getstatus_failed;
+                        $_->{avatar_names} = $res ? $res->{avatar_names} : "NO USER";
+                }
+        }
+        my $html = &MonitorGUI::View::html(\%copy_obj);
+    &MyCGI::outputHtml("UTF-8", &MonitorGUI::View::screen_header . $html . &MonitorGUI::View::screen_footer);
+}
+
+sub gui_error {
+    my $msg = shift;
+    &MyCGI::outputHtml("UTF-8", "<h1>ERROR</h1><hr />$msg");
+}
+
+sub redirect_refresh {
+    my $args = shift;
+    my $wait = $args->{wait};
+    my $force = $args->{force} || "";
+    my $msg = $args->{msg} || "";
+    my $param = "A=refresh&wait=$wait&ip=$force&msg=$msg";
+    my $dist_url = $THIS_URL . "?" . $param;
+    &MyCGI::redirect($dist_url);
+}
+
+sub refresh {
+    my $param = shift;
+    my $msg = $param->{msg} || "";
+    my $wait = $param->{wait} || 0;
+    my $force = $param->{ip} || "";
+    #my $jump_url = $force ? "$THIS_URL?A=force&ip=$force" : $THIS_URL;
+    my $jump_url = $THIS_URL;
+    my $html =<< "HTML";
+<html>
+<head>
+<meta http-equiv="Refresh" content="$wait;URL=$jump_url" />
+<title>Region Monitor GUI REFRESH</title>
+</head>
+<body>
+<h3>$msg</h3>
+<br>
+wait <font color="red"><b>$wait</b></font> sec for server to take effect ... <br>
+(* The page will jump to "Monitor Screen" automatically)
+</body>
+</html>
+HTML
+    &MyCGI::outputHtml("UTF-8", $html);
+}
+
+# ##################
+# Utility
+sub XMLRPCCall {
+    my ($url, $methodname, $param) = @_;
+    my $xmlrpc = new XML::RPC($url);
+    my $result = $xmlrpc->call($methodname, $param);
+    return $result;
+}
+
+sub XMLRPCCall_array {
+    my ($url, $methodname, $param) = @_;
+    my $xmlrpc = new XML::RPC($url);
+    my $result = $xmlrpc->call($methodname, @$param);
+    return $result;
+}
+
diff --git a/ThirdParty/3Di/RegionMonitor/ServerPlugin/RegionMonitorPlugin.cs b/ThirdParty/3Di/RegionMonitor/ServerPlugin/RegionMonitorPlugin.cs
new file mode 100644
index 0000000..5d2df3a
--- /dev/null
+++ b/ThirdParty/3Di/RegionMonitor/ServerPlugin/RegionMonitorPlugin.cs
@@ -0,0 +1,129 @@
+/*
+* 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.Runtime.Remoting;
+using System.Threading;
+using Mono.Addins;
+using OpenSim;
+using OpenSim.Framework.Console;
+using MonitorLib;
+
+[assembly:Addin]
+[assembly:AddinDependency ("OpenSim", "0.5")]
+
+namespace OpenSim.ApplicationPlugins.RegionMonitor
+{
+        [Extension("/OpenSim/Startup")]
+        public class RegionMonitorPlugin : MonitorLibBase, IApplicationPlugin
+        {
+                protected Thread m_mointorThread;
+                protected static OpenSimMain m_openSimMain;
+
+                public void Initialise(OpenSimMain opensim)
+                {
+                        m_openSimMain = opensim;
+                        Start();
+                        MainLog.Instance.Verbose("Monitor", "Region monitor is runing ...");
+                }
+
+                public void Close()
+                {
+                }
+
+                public void Start()

+                {
+                        // start monitor thread (remoting module)
+                        m_mointorThread = new Thread(new ThreadStart(StartMonitor));
+                        m_mointorThread.IsBackground = true;
+                        m_mointorThread.Start();
+                }
+
+                private void StartMonitor()
+                {
+                        try
+                        {
+                                Object lockObj = new Object();
+
+                                RemotingConfiguration.Configure("monitorS.config", false);
+
+                                lock (lockObj)
+                                {
+                                        System.Threading.Monitor.Wait(lockObj);
+                                }
+                        }
+                        catch (Exception e)
+                        {
+                                MainLog.Instance.Warn("MONITOR", "Error - " + e.Message);
+                        }
+                }
+
+                public override bool FetchInfo(out string outstr)
+                {
+                        MainLog.Instance.Verbose("MONITOR", "Fetch Information from Region server");
+                        bool status = true;
+                        string startTime = "";
+                        string upTime = "";
+                        int userNumber = 0;
+                        int regionNumber = 0;
+                        m_openSimMain.GetRunTime(out startTime, out upTime);
+                        m_openSimMain.GetAvatarNumber(out userNumber);
+                        m_openSimMain.GetRegionNumber(out regionNumber);
+                        outstr = startTime
+                                        + "," + upTime
+                                        + "," + regionNumber
+                                        + "," + userNumber;
+                        return status;
+                }
+
+
+                public override bool MoveRegion()
+                {
+                        MainLog.Instance.Verbose("MONITOR", "Move Region");
+                        bool status = true;
+
+                        return status;
+                }
+
+                public override bool SplitRegion()
+                {
+                        MainLog.Instance.Verbose("MONITOR", "Split Region");
+                        bool status = true;
+
+                        return status;
+                }
+
+                public override bool MergeScenes()
+                {
+                        MainLog.Instance.Verbose("MONITOR", "Merge Scenes");
+                        bool status = true;
+
+                        return status;
+                }
+
+        }
+}
diff --git a/ThirdParty/3Di/RegionProxy/RegionProxyPlugin.cs b/ThirdParty/3Di/RegionProxy/RegionProxyPlugin.cs
new file mode 100644
index 0000000..13aec48
--- /dev/null
+++ b/ThirdParty/3Di/RegionProxy/RegionProxyPlugin.cs
@@ -0,0 +1,513 @@
+/*
+* 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.IO;
+using System.Net;
+using System.Xml;
+using System.Text;
+using System.Xml.Serialization;
+using System.Net.Sockets;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Console;
+using Nwc.XmlRpc;
+
+using Mono.Addins;
+
+[assembly:Addin]
+[assembly:AddinDependency ("OpenSim", "0.5")]
+
+namespace OpenSim.ApplicationPlugins.RegionProxy
+{
+    /* This module has an interface to OpenSim clients that is constant, and is responsible for relaying
+     * messages to and from clients to the region objects. Since the region objects can be duplicated and
+     * moved dynamically, the proxy provides methods for changing and adding regions. If more than one region
+     * is associated with a client port, then the message will be broadcasted to all those regions.
+     *
+     * The client interface port may be blocked. While being blocked, all messages from the clients will be
+     * stored in the proxy. Once the interface port is unblocked again, all stored messages will be resent
+     * to the regions. This functionality is used when moving or cloning an region to make sure that no messages
+     * are sent to the region while it is being reconfigured.
+     *
+     * The proxy opens a XmlRpc interface with these public methods:
+     * - AddPort
+     * - AddRegion
+     * - ChangeRegion
+     * - BlockClientMessages
+     * - UnblockClientMessages
+     */
+
+    [Extension("/OpenSim/Startup")]
+    public class RegionProxyPlugin : IApplicationPlugin
+    {
+        private ProxyServer proxy;
+        private BaseHttpServer command_server;
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        public void Initialise(OpenSimMain openSim)
+        {
+            Console.WriteLine("Starting proxy");
+            string proxyURL = openSim.ConfigSource.Configs["Network"].GetString("proxy_url", "");
+                if(proxyURL.Length==0) return;
+
+            uint port = (uint) Int32.Parse(proxyURL.Split(new char[] { ':' })[2]);
+            command_server = new BaseHttpServer(port);
+            command_server.Start();
+            command_server.AddXmlRPCHandler("AddPort", AddPort);
+            command_server.AddXmlRPCHandler("AddRegion", AddRegion);
+            command_server.AddXmlRPCHandler("DeleteRegion", DeleteRegion);
+            command_server.AddXmlRPCHandler("ChangeRegion", ChangeRegion);
+            command_server.AddXmlRPCHandler("BlockClientMessages", BlockClientMessages);
+            command_server.AddXmlRPCHandler("UnblockClientMessages", UnblockClientMessages);
+            command_server.AddXmlRPCHandler("Stop", Stop);
+
+            proxy=new ProxyServer(m_log);
+        }
+
+        public void Close()
+        {
+        }
+
+        private XmlRpcResponse Stop(XmlRpcRequest request)
+        {
+            try
+            {
+                proxy.Stop();
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[PROXY]" + e.Message);
+                m_log.Error("[PROXY]" + e.StackTrace);
+            }
+            return new XmlRpcResponse();
+        }
+
+        private XmlRpcResponse AddPort(XmlRpcRequest request)
+            {
+            try {
+                int clientPort = (int) request.Params[0];
+                int regionPort = (int) request.Params[1];
+                string regionUrl = (string) request.Params[2];
+                proxy.AddPort(clientPort, regionPort, regionUrl);
+            } catch(Exception e) {
+                m_log.Error("[PROXY]"+e.Message);
+                m_log.Error("[PROXY]"+e.StackTrace);
+            }
+                return new XmlRpcResponse();
+            }
+
+        private XmlRpcResponse AddRegion(XmlRpcRequest request)
+        {
+            try {
+                int currentRegionPort = (int) request.Params[0];
+                string currentRegionUrl = (string) request.Params[1];
+                int newRegionPort = (int) request.Params[2];
+                string newRegionUrl = (string) request.Params[3];
+                proxy.AddRegion(currentRegionPort, currentRegionUrl, newRegionPort, newRegionUrl);
+            } catch(Exception e) {
+                m_log.Error("[PROXY]"+e.Message);
+                m_log.Error("[PROXY]"+e.StackTrace);
+            }
+                return new XmlRpcResponse();
+            }
+
+        private XmlRpcResponse ChangeRegion(XmlRpcRequest request)
+        {
+            try {
+                int currentRegionPort = (int) request.Params[0];
+                string currentRegionUrl = (string) request.Params[1];
+                int newRegionPort = (int) request.Params[2];
+                string newRegionUrl = (string) request.Params[3];
+                proxy.ChangeRegion(currentRegionPort, currentRegionUrl, newRegionPort, newRegionUrl);
+            } catch(Exception e) {
+                m_log.Error("[PROXY]"+e.Message);
+                m_log.Error("[PROXY]"+e.StackTrace);
+            }
+                return new XmlRpcResponse();
+            }
+                
+        private XmlRpcResponse DeleteRegion(XmlRpcRequest request)
+        {
+            try {
+                int currentRegionPort = (int) request.Params[0];
+                string currentRegionUrl = (string) request.Params[1];
+                proxy.DeleteRegion(currentRegionPort, currentRegionUrl);
+            } catch(Exception e) {
+                m_log.Error("[PROXY]"+e.Message);
+                m_log.Error("[PROXY]"+e.StackTrace);
+            }
+                return new XmlRpcResponse();
+            }
+
+        private XmlRpcResponse BlockClientMessages(XmlRpcRequest request)
+        {
+            try {
+                string regionUrl = (string) request.Params[0];
+                int regionPort = (int) request.Params[1];
+                proxy.BlockClientMessages(regionUrl, regionPort);
+            } catch(Exception e) {
+                m_log.Error("[PROXY]"+e.Message);
+                m_log.Error("[PROXY]"+e.StackTrace);
+            }
+                return new XmlRpcResponse();
+            }
+
+        private XmlRpcResponse UnblockClientMessages(XmlRpcRequest request)
+        {
+            try {
+                string regionUrl = (string) request.Params[0];
+                int regionPort = (int) request.Params[1];
+                proxy.UnblockClientMessages(regionUrl, regionPort);
+            } catch(Exception e) {
+                m_log.Error("[PROXY]"+e.Message); 
+                m_log.Error("[PROXY]"+e.StackTrace);
+            }
+                return new XmlRpcResponse();
+            }
+    }
+
+
+    public class ProxyServer {
+        protected AsyncCallback receivedData;
+        protected ProxyMap proxy_map = new ProxyMap();
+        protected readonly log4net.ILog m_log;
+        protected bool running;
+
+        protected class ProxyMap
+        {
+            public class RegionData
+            {
+                public bool isBlocked = false;
+                public Queue storedMessages = new Queue();
+                public List<EndPoint> regions = new List<EndPoint>();
+            }
+
+            private Dictionary<EndPoint, RegionData> map;
+
+            public ProxyMap() {
+                map = new Dictionary<EndPoint, RegionData>();
+            }
+
+            public void Add(EndPoint client, EndPoint region)
+            {
+                if(map.ContainsKey(client)) 
+                {
+                    map[client].regions.Add(region);
+                }
+                else
+                {
+                    RegionData regions = new RegionData();
+                    map.Add(client, regions);
+                    regions.regions.Add(region);
+                }
+            }
+
+            public RegionData GetRegionData(EndPoint client)
+            {
+                return map[client];
+            }
+
+            public EndPoint GetClient(EndPoint region)
+            {
+                foreach (KeyValuePair<EndPoint, RegionData> pair in map)
+                {
+                    if(pair.Value.regions.Contains(region))
+                    {
+                        return pair.Key;
+                    }
+                }
+                return null;
+            }
+        }
+
+        protected class ServerData {
+            public Socket server;
+            public EndPoint clientEP;
+            public EndPoint senderEP;
+            public IPEndPoint serverIP;
+                     public byte[] recvBuffer = new byte[4096];
+
+            public ServerData()
+            {
+                server = null;
+            }
+        }
+
+        protected class StoredMessage
+        {
+            public byte[] buffer;
+            public int length;
+            public EndPoint senderEP;
+            public ServerData sd;
+
+            public StoredMessage(byte[] buffer, int length, int maxLength, EndPoint senderEP, ServerData sd)
+            {
+                this.buffer = new byte[maxLength];
+                this.length = length;
+                for(int i=0; i<length; i++) this.buffer[i]=buffer[i];
+                this.senderEP = senderEP;
+                this.sd = sd;
+            }
+        }
+
+        public ProxyServer(log4net.ILog log)
+        {
+            m_log = log;
+            running=false;
+            receivedData = new AsyncCallback(OnReceivedData);
+        }
+
+        public void BlockClientMessages(string regionUrl, int regionPort)
+        {
+            EndPoint client = proxy_map.GetClient(new IPEndPoint(IPAddress.Parse(regionUrl), regionPort));
+            ProxyMap.RegionData rd = proxy_map.GetRegionData(client);
+            rd.isBlocked = true;
+        }
+
+        public void UnblockClientMessages(string regionUrl, int regionPort)
+        {
+            EndPoint client = proxy_map.GetClient(new IPEndPoint(IPAddress.Parse(regionUrl), regionPort));
+            ProxyMap.RegionData rd = proxy_map.GetRegionData(client);
+
+            rd.isBlocked = false;
+            while(rd.storedMessages.Count > 0) {
+                StoredMessage msg = (StoredMessage) rd.storedMessages.Dequeue();
+                //m_log.Verbose("[PROXY]"+"Resending blocked message from {0}", msg.senderEP);
+                SendMessage(msg.buffer, msg.length, msg.senderEP, msg.sd);
+            }
+        }
+
+        public void AddRegion(int oldRegionPort, string oldRegionUrl, int newRegionPort, string newRegionUrl)
+        {
+            //m_log.Verbose("[PROXY]"+"AddRegion {0} {1}", oldRegionPort, newRegionPort);
+            EndPoint client = proxy_map.GetClient(new IPEndPoint(IPAddress.Parse(oldRegionUrl), oldRegionPort));
+            ProxyMap.RegionData data = proxy_map.GetRegionData(client);
+            data.regions.Add(new IPEndPoint(IPAddress.Parse(newRegionUrl), newRegionPort));
+        }
+
+        public void ChangeRegion(int oldRegionPort, string oldRegionUrl, int newRegionPort, string newRegionUrl)
+        {
+            //m_log.Verbose("[PROXY]"+"ChangeRegion {0} {1}", oldRegionPort, newRegionPort);
+            EndPoint client = proxy_map.GetClient(new IPEndPoint(IPAddress.Parse(oldRegionUrl), oldRegionPort));
+            ProxyMap.RegionData data = proxy_map.GetRegionData(client);
+            data.regions.Clear();
+            data.regions.Add(new IPEndPoint(IPAddress.Parse(newRegionUrl), newRegionPort));
+        }
+                
+        public void DeleteRegion(int oldRegionPort, string oldRegionUrl)
+        {
+            m_log.InfoFormat("[PROXY]"+"DeleteRegion {0} {1}", oldRegionPort, oldRegionUrl);
+                        EndPoint regionEP = new IPEndPoint(IPAddress.Parse(oldRegionUrl), oldRegionPort);
+            EndPoint client = proxy_map.GetClient(regionEP);
+            ProxyMap.RegionData data = proxy_map.GetRegionData(client);
+                        data.regions.Remove(regionEP);
+        }
+
+        public void AddPort(int clientPort, int regionPort, string regionUrl)
+        {
+            running = true;
+
+            //m_log.Verbose("[PROXY]"+"AddPort {0} {1}", clientPort, regionPort);
+            IPEndPoint clientEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), clientPort);
+            proxy_map.Add(clientEP, new IPEndPoint(IPAddress.Parse(regionUrl), regionPort));
+
+            ServerData sd = new ServerData();
+            sd.clientEP = new IPEndPoint(clientEP.Address, clientEP.Port);
+
+            OpenPort(sd);
+        }
+
+        protected void OpenPort(ServerData sd)
+        {
+            // sd.clientEP must be set before calling this function
+
+            ClosePort(sd);
+
+            try
+            {
+                   
+                m_log.InfoFormat("[PROXY] Opening UDP socket on {0}", sd.clientEP);
+                sd.serverIP = new IPEndPoint(IPAddress.Parse("0.0.0.0"), ((IPEndPoint)sd.clientEP).Port);
+                sd.server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+                sd.server.Bind(sd.serverIP);
+
+                sd.senderEP = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 0);
+                //receivedData = new AsyncCallback(OnReceivedData);
+                sd.server.BeginReceiveFrom(sd.recvBuffer, 0, sd.recvBuffer.Length, SocketFlags.None, ref sd.senderEP, receivedData, sd);
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[PROXY] Failed to (re)open socket {0}", sd.clientEP);
+                m_log.Error("[PROXY]" + e.Message);
+                m_log.Error("[PROXY]" + e.StackTrace);
+            }
+        }
+
+        protected void ClosePort(ServerData sd)
+        {
+            // Close the port if it exists and is open
+            if (sd.server == null) return;
+
+            try
+            {
+                sd.server.Shutdown(SocketShutdown.Both);
+                sd.server.Close();
+            }
+            catch (Exception)
+            {
+            }
+        }
+
+        public void Stop()
+        {
+            running = false;
+            m_log.InfoFormat("[PROXY] Stopping the proxy server");
+
+        }
+
+
+        protected virtual void OnReceivedData(IAsyncResult result)
+        {
+            if(!running) return;
+                
+            ServerData sd = (ServerData)result.AsyncState;
+            sd.senderEP = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 0);
+
+            try
+            {
+                int numBytes = sd.server.EndReceiveFrom(result, ref sd.senderEP);
+                                if (numBytes > 0)
+                                {
+                                        SendMessage(sd.recvBuffer, numBytes, sd.senderEP, sd);
+                                }
+            }
+            catch (Exception e)
+            {
+//                OpenPort(sd); // reopen the port just in case
+                m_log.ErrorFormat("[PROXY] EndReceiveFrom failed in {0}", sd.clientEP);
+                m_log.Error("[PROXY]" + e.Message);
+                m_log.Error("[PROXY]" + e.StackTrace);
+            }
+
+            WaitForNextMessage(sd);
+        }
+
+        protected void WaitForNextMessage(ServerData sd)
+        {
+            bool error = true;
+            while (error)
+            {
+                error = false;
+                try
+                {
+                    sd.server.BeginReceiveFrom(sd.recvBuffer, 0, sd.recvBuffer.Length, SocketFlags.None, ref sd.senderEP, receivedData, sd);
+                }
+                catch (Exception e)
+                {
+                    error = true;
+                    m_log.ErrorFormat("[PROXY] BeginReceiveFrom failed, retrying... {0}", sd.clientEP);
+                    m_log.Error("[PROXY]" + e.Message);
+                    m_log.Error("[PROXY]" + e.StackTrace);
+                    OpenPort(sd); 
+                }
+            }
+        }
+
+        protected void SendMessage(byte[] buffer, int length, EndPoint senderEP, ServerData sd)
+        {
+            int numBytes = length;
+
+            //m_log.ErrorFormat("[PROXY] Got message from {0} in thread {1}, size {2}", senderEP, sd.clientEP, numBytes);
+            EndPoint client = proxy_map.GetClient(senderEP);
+
+            if (client != null)
+            {
+                try
+                {
+                    client = PacketPool.DecodeProxyMessage(buffer, ref numBytes);
+                    try
+                    {
+                        // This message comes from a region object, forward it to the its client
+                        sd.server.SendTo(buffer, numBytes, SocketFlags.None, client);
+                        //m_log.InfoFormat("[PROXY] Sending region message from {0} to {1}, size {2}", senderEP, client, numBytes);
+                    }
+                    catch (Exception e)
+                    {
+                        OpenPort(sd); // reopen the port just in case
+                        m_log.ErrorFormat("[PROXY] Failed sending region message from {0} to {1}", senderEP, client);
+                        m_log.Error("[PROXY]" + e.Message);
+                        m_log.Error("[PROXY]" + e.StackTrace);
+                        return;
+                    }
+                }
+                catch (Exception e)
+                {
+                    OpenPort(sd); // reopen the port just in case
+                    m_log.ErrorFormat("[PROXY] Failed decoding region message from {0}", senderEP);
+                    m_log.Error("[PROXY]" + e.Message);
+                    m_log.Error("[PROXY]" + e.StackTrace);
+                    return;
+                }
+
+            }
+            else
+            {
+                // This message comes from a client object, forward it to the the region(s)
+                PacketPool.EncodeProxyMessage(buffer, ref numBytes, senderEP);
+                ProxyMap.RegionData rd = proxy_map.GetRegionData(sd.clientEP);
+                foreach (EndPoint region in rd.regions)
+                {
+                    if(rd.isBlocked) {
+                        rd.storedMessages.Enqueue(new StoredMessage(buffer, length, numBytes, senderEP, sd));
+                    }
+                    else
+                    {
+                        try
+                        {
+                            sd.server.SendTo(buffer, numBytes, SocketFlags.None, region);
+                            //m_log.InfoFormat("[PROXY] Sending client message from {0} to {1}", senderEP, region);
+                        }
+                        catch (Exception e)
+                        {
+                            OpenPort(sd); // reopen the port just in case
+                            m_log.ErrorFormat("[PROXY] Failed sending client message from {0} to {1}", senderEP, region);
+                            m_log.Error("[PROXY]" + e.Message);
+                            m_log.Error("[PROXY]" + e.StackTrace);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}