Merge branch 'master' into careminster-presence-refactor

This brings careminster on the level of master. To be tested

8 files changed, 3036 insertions, 16 deletions

diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
new file mode 100644
index 0000000..80c0af8
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
@@ -0,0 +1,1602 @@
+/*
+ * 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 OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+using System.Threading;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Client;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+
+namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
+{
+    public class EntityTransferModule : ISharedRegionModule, IEntityTransferModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected bool m_Enabled = false;
+        protected Scene m_aScene;
+        protected List<UUID> m_agentsInTransit;
+
+        #region ISharedRegionModule
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public virtual string Name
+        {
+            get { return "BasicEntityTransferModule"; }
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("EntityTransferModule", "");
+                if (name == Name)
+                {
+                    m_agentsInTransit = new List<UUID>();
+                    m_Enabled = true;
+                    m_log.InfoFormat("[ENTITY TRANSFER MODULE]: {0} enabled.", Name);
+                }
+            }
+        }
+
+        public virtual void PostInitialise()
+        {
+        }
+
+        public virtual void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            if (m_aScene == null)
+                m_aScene = scene;
+
+            scene.RegisterModuleInterface<IEntityTransferModule>(this);
+            scene.EventManager.OnNewClient += OnNewClient;
+        }
+
+        protected virtual void OnNewClient(IClientAPI client)
+        {
+            client.OnTeleportHomeRequest += TeleportHome;
+        }
+
+        public virtual void Close()
+        {
+            if (!m_Enabled)
+                return;
+        }
+
+
+        public virtual void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+            if (scene == m_aScene)
+                m_aScene = null;
+        }
+
+        public virtual void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+        }
+
+
+        #endregion
+
+        #region Agent Teleports
+
+        public void Teleport(ScenePresence sp, ulong regionHandle, Vector3 position, Vector3 lookAt, uint teleportFlags)
+        {
+            if (!sp.Scene.Permissions.CanTeleport(sp.UUID))
+                return;
+
+            IEventQueue eq = sp.Scene.RequestModuleInterface<IEventQueue>();
+
+            // Reset animations; the viewer does that in teleports.
+            sp.Animator.ResetAnimations();
+
+            try
+            {
+                if (regionHandle == sp.Scene.RegionInfo.RegionHandle)
+                {
+                    m_log.DebugFormat(
+                        "[ENTITY TRANSFER MODULE]: RequestTeleportToLocation {0} within {1}",
+                        position, sp.Scene.RegionInfo.RegionName);
+
+                    // Teleport within the same region
+                    if (IsOutsideRegion(sp.Scene, position) || position.Z < 0)
+                    {
+                        Vector3 emergencyPos = new Vector3(128, 128, 128);
+
+                        m_log.WarnFormat(
+                            "[ENTITY TRANSFER MODULE]: RequestTeleportToLocation() was given an illegal position of {0} for avatar {1}, {2}.  Substituting {3}",
+                            position, sp.Name, sp.UUID, emergencyPos);
+                        position = emergencyPos;
+                    }
+
+                    // TODO: Get proper AVG Height
+                    float localAVHeight = 1.56f;
+                    float posZLimit = 22;
+
+                    // TODO: Check other Scene HeightField
+                    if (position.X > 0 && position.X <= (int)Constants.RegionSize && position.Y > 0 && position.Y <= (int)Constants.RegionSize)
+                    {
+                        posZLimit = (float)sp.Scene.Heightmap[(int)position.X, (int)position.Y];
+                    }
+
+                    float newPosZ = posZLimit + localAVHeight;
+                    if (posZLimit >= (position.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
+                    {
+                        position.Z = newPosZ;
+                    }
+
+                    // Only send this if the event queue is null
+                    if (eq == null)
+                        sp.ControllingClient.SendTeleportLocationStart();
+
+                    sp.ControllingClient.SendLocalTeleport(position, lookAt, teleportFlags);
+                    sp.Teleport(position);
+                }
+                else // Another region possibly in another simulator
+                {
+                    uint x = 0, y = 0;
+                    Utils.LongToUInts(regionHandle, out x, out y);
+                    GridRegion reg = m_aScene.GridService.GetRegionByPosition(sp.Scene.RegionInfo.ScopeID, (int)x, (int)y);
+
+                    if (reg != null)
+                    {
+                        GridRegion finalDestination = GetFinalDestination(reg);
+                        if (finalDestination == null)
+                        {
+                            m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Final destination is having problems. Unable to teleport agent.");
+                            sp.ControllingClient.SendTeleportFailed("Problem at destination");
+                            return;
+                        }
+                        m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Final destination is x={0} y={1} uuid={2}",
+                            finalDestination.RegionLocX / Constants.RegionSize, finalDestination.RegionLocY / Constants.RegionSize, finalDestination.RegionID);
+
+                        //
+                        // This is it
+                        //
+                        DoTeleport(sp, reg, finalDestination, position, lookAt, teleportFlags, eq);
+                        //
+                        //
+                        //
+                    }
+                    else
+                    {
+                        // TP to a place that doesn't exist (anymore)
+                        // Inform the viewer about that
+                        sp.ControllingClient.SendTeleportFailed("The region you tried to teleport to doesn't exist anymore");
+
+                        // and set the map-tile to '(Offline)'
+                        uint regX, regY;
+                        Utils.LongToUInts(regionHandle, out regX, out regY);
+
+                        MapBlockData block = new MapBlockData();
+                        block.X = (ushort)(regX / Constants.RegionSize);
+                        block.Y = (ushort)(regY / Constants.RegionSize);
+                        block.Access = 254; // == not there
+
+                        List<MapBlockData> blocks = new List<MapBlockData>();
+                        blocks.Add(block);
+                        sp.ControllingClient.SendMapBlock(blocks, 0);
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Exception on teleport: {0}\n{1}", e.Message, e.StackTrace);
+                sp.ControllingClient.SendTeleportFailed("Internal error");
+            }
+        }
+
+        protected void DoTeleport(ScenePresence sp, GridRegion reg, GridRegion finalDestination, Vector3 position, Vector3 lookAt, uint teleportFlags, IEventQueue eq)
+        {
+            if (reg == null || finalDestination == null)
+            {
+                sp.ControllingClient.SendTeleportFailed("Unable to locate destination");
+                return;
+            }
+
+            m_log.DebugFormat(
+                "[ENTITY TRANSFER MODULE]: Request Teleport to {0}:{1}:{2}/{3}",
+                reg.ExternalHostName, reg.HttpPort, finalDestination.RegionName, position);
+
+            uint newRegionX = (uint)(reg.RegionHandle >> 40);
+            uint newRegionY = (((uint)(reg.RegionHandle)) >> 8);
+            uint oldRegionX = (uint)(sp.Scene.RegionInfo.RegionHandle >> 40);
+            uint oldRegionY = (((uint)(sp.Scene.RegionInfo.RegionHandle)) >> 8);
+
+            ulong destinationHandle = finalDestination.RegionHandle;
+
+            if (eq == null)
+                sp.ControllingClient.SendTeleportLocationStart();
+
+            // Let's do DNS resolution only once in this process, please!
+            // This may be a costly operation. The reg.ExternalEndPoint field is not a passive field,
+            // it's actually doing a lot of work.
+            IPEndPoint endPoint = finalDestination.ExternalEndPoint;
+            if (endPoint.Address != null)
+            {
+                // Fixing a bug where teleporting while sitting results in the avatar ending up removed from
+                // both regions
+                if (sp.ParentID != (uint)0)
+                    sp.StandUp();
+
+                if (!sp.ValidateAttachments())
+                {
+                    sp.ControllingClient.SendTeleportFailed("Inconsistent attachment state");
+                    return;
+                }
+
+                // the avatar.Close below will clear the child region list. We need this below for (possibly)
+                // closing the child agents, so save it here (we need a copy as it is Clear()-ed).
+                //List<ulong> childRegions = new List<ulong>(avatar.GetKnownRegionList());
+                // Compared to ScenePresence.CrossToNewRegion(), there's no obvious code to handle a teleport
+                // failure at this point (unlike a border crossing failure).  So perhaps this can never fail
+                // once we reach here...
+                //avatar.Scene.RemoveCapsHandler(avatar.UUID);
+
+                string capsPath = String.Empty;
+
+                AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
+                AgentCircuitData agentCircuit = sp.ControllingClient.RequestClientInfo();
+                agentCircuit.startpos = position;
+                agentCircuit.child = true;
+                agentCircuit.Appearance = sp.Appearance;
+                if (currentAgentCircuit != null)
+                    agentCircuit.ServiceURLs = currentAgentCircuit.ServiceURLs;
+
+                if (NeedsNewAgent(oldRegionX, newRegionX, oldRegionY, newRegionY))
+                {
+                    // brand new agent, let's create a new caps seed
+                    agentCircuit.CapsPath = CapsUtil.GetRandomCapsObjectPath();
+                }
+
+                string reason = String.Empty;
+
+                // Let's create an agent there if one doesn't exist yet. 
+                if (!CreateAgent(sp, reg, finalDestination, agentCircuit, teleportFlags, out reason))
+                {
+                    sp.ControllingClient.SendTeleportFailed(String.Format("Destination refused: {0}",
+                                                                              reason));
+                    return;
+                }
+
+                // OK, it got this agent. Let's close some child agents
+                sp.CloseChildAgents(newRegionX, newRegionY);
+
+                if (NeedsNewAgent(oldRegionX, newRegionX, oldRegionY, newRegionY))
+                {
+                    #region IP Translation for NAT
+                    IClientIPEndpoint ipepClient;
+                    if (sp.ClientView.TryGet(out ipepClient))
+                    {
+                        capsPath
+                            = "http://"
+                              + NetworkUtil.GetHostFor(ipepClient.EndPoint, finalDestination.ExternalHostName)
+                              + ":"
+                              + finalDestination.HttpPort
+                              + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
+                    }
+                    else
+                    {
+                        capsPath
+                            = "http://"
+                              + finalDestination.ExternalHostName
+                              + ":"
+                              + finalDestination.HttpPort
+                              + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
+                    }
+                    #endregion
+
+                    if (eq != null)
+                    {
+                        #region IP Translation for NAT
+                        // Uses ipepClient above
+                        if (sp.ClientView.TryGet(out ipepClient))
+                        {
+                            endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
+                        }
+                        #endregion
+
+                        eq.EnableSimulator(destinationHandle, endPoint, sp.UUID);
+
+                        // ES makes the client send a UseCircuitCode message to the destination, 
+                        // which triggers a bunch of things there.
+                        // So let's wait
+                        Thread.Sleep(200);
+
+                        eq.EstablishAgentCommunication(sp.UUID, endPoint, capsPath);
+
+                    }
+                    else
+                    {
+                        sp.ControllingClient.InformClientOfNeighbour(destinationHandle, endPoint);
+                    }
+                }
+                else
+                {
+                    agentCircuit.CapsPath = sp.Scene.CapsModule.GetChildSeed(sp.UUID, reg.RegionHandle);
+                    capsPath = "http://" + finalDestination.ExternalHostName + ":" + finalDestination.HttpPort
+                                + "/CAPS/" + agentCircuit.CapsPath + "0000/";
+                }
+
+                // Expect avatar crossing is a heavy-duty function at the destination.
+                // That is where MakeRoot is called, which fetches appearance and inventory.
+                // Plus triggers OnMakeRoot, which spawns a series of asynchronous updates.
+                //m_commsProvider.InterRegion.ExpectAvatarCrossing(reg.RegionHandle, avatar.ControllingClient.AgentId,
+                //                                                      position, false);
+
+                //{
+                //    avatar.ControllingClient.SendTeleportFailed("Problem with destination.");
+                //    // We should close that agent we just created over at destination...
+                //    List<ulong> lst = new List<ulong>();
+                //    lst.Add(reg.RegionHandle);
+                //    SendCloseChildAgentAsync(avatar.UUID, lst);
+                //    return;
+                //}
+
+                SetInTransit(sp.UUID);
+
+                // Let's send a full update of the agent. This is a synchronous call.
+                AgentData agent = new AgentData();
+                sp.CopyTo(agent);
+                agent.Position = position;
+                SetCallbackURL(agent, sp.Scene.RegionInfo);
+
+                UpdateAgent(reg, finalDestination, agent);
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} to client {1}", capsPath, sp.UUID);
+
+
+                if (eq != null)
+                {
+                    eq.TeleportFinishEvent(destinationHandle, 13, endPoint,
+                                           0, teleportFlags, capsPath, sp.UUID);
+                }
+                else
+                {
+                    sp.ControllingClient.SendRegionTeleport(destinationHandle, 13, endPoint, 4,
+                                                                teleportFlags, capsPath);
+                }
+
+                // TeleportFinish makes the client send CompleteMovementIntoRegion (at the destination), which
+                // trigers a whole shebang of things there, including MakeRoot. So let's wait for confirmation
+                // that the client contacted the destination before we send the attachments and close things here.
+                if (!WaitForCallback(sp.UUID))
+                {
+                    // Client never contacted destination. Let's restore everything back
+                    sp.ControllingClient.SendTeleportFailed("Problems connecting to destination.");
+
+                    ResetFromTransit(sp.UUID);
+
+                    // Yikes! We should just have a ref to scene here.
+                    //sp.Scene.InformClientOfNeighbours(sp);
+                    EnableChildAgents(sp);
+
+                    // Finally, kill the agent we just created at the destination.
+                    m_aScene.SimulationService.CloseAgent(finalDestination, sp.UUID);
+
+                    return;
+                }
+
+
+                // CrossAttachmentsIntoNewRegion is a synchronous call. We shouldn't need to wait after it
+                CrossAttachmentsIntoNewRegion(finalDestination, sp, true);
+
+                KillEntity(sp.Scene, sp.LocalId);
+
+                sp.MakeChildAgent();
+                // Finally, let's close this previously-known-as-root agent, when the jump is outside the view zone
+
+                if (NeedsClosing(oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
+                {
+                    Thread.Sleep(5000);
+                    sp.Close();
+                    sp.Scene.IncomingCloseAgent(sp.UUID);
+                }
+                else
+                    // now we have a child agent in this region. 
+                    sp.Reset();
+
+
+                // REFACTORING PROBLEM. Well, not a problem, but this method is HORRIBLE!
+                if (sp.Scene.NeedSceneCacheClear(sp.UUID))
+                {
+                    m_log.DebugFormat(
+                        "[ENTITY TRANSFER MODULE]: User {0} is going to another region, profile cache removed",
+                        sp.UUID);
+                }
+            }
+            else
+            {
+                sp.ControllingClient.SendTeleportFailed("Remote Region appears to be down");
+            }
+        }
+
+
+        protected virtual bool CreateAgent(ScenePresence sp, GridRegion reg, GridRegion finalDestination, AgentCircuitData agentCircuit, uint teleportFlags, out string reason)
+        {
+            return m_aScene.SimulationService.CreateAgent(finalDestination, agentCircuit, teleportFlags, out reason);
+        }
+
+        protected virtual bool UpdateAgent(GridRegion reg, GridRegion finalDestination, AgentData agent)
+        {
+            return m_aScene.SimulationService.UpdateAgent(finalDestination, agent);
+        }
+
+        protected virtual void SetCallbackURL(AgentData agent, RegionInfo region)
+        {
+            agent.CallbackURI = "http://" + region.ExternalHostName + ":" + region.HttpPort +
+                "/agent/" + agent.AgentID.ToString() + "/" + region.RegionID.ToString() + "/release/";
+
+        }
+
+        protected void KillEntity(Scene scene, uint localID)
+        {
+            scene.SendKillObject(localID);
+        }
+
+        protected virtual GridRegion GetFinalDestination(GridRegion region)
+        {
+            return region;
+        }
+
+        protected virtual bool NeedsNewAgent(uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY)
+        {
+            return Util.IsOutsideView(oldRegionX, newRegionX, oldRegionY, newRegionY);
+        }
+
+        protected virtual bool NeedsClosing(uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY, GridRegion reg)
+        {
+            return Util.IsOutsideView(oldRegionX, newRegionX, oldRegionY, newRegionY);
+        }
+
+        protected virtual bool IsOutsideRegion(Scene s, Vector3 pos)
+        {
+
+            if (s.TestBorderCross(pos, Cardinals.N))
+                return true;
+            if (s.TestBorderCross(pos, Cardinals.S))
+                return true;
+            if (s.TestBorderCross(pos, Cardinals.E))
+                return true;
+            if (s.TestBorderCross(pos, Cardinals.W))
+                return true;
+
+            return false;
+        }
+
+
+        #endregion
+
+        #region Teleport Home
+
+        public virtual void TeleportHome(UUID id, IClientAPI client)
+        {
+            m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Request to teleport {0} {1} home", client.FirstName, client.LastName);
+
+            OpenSim.Services.Interfaces.PresenceInfo pinfo = m_aScene.PresenceService.GetAgent(client.SessionId);
+
+            if (pinfo != null)
+            {
+                GridRegion regionInfo = m_aScene.GridService.GetRegionByUUID(UUID.Zero, pinfo.HomeRegionID);
+                if (regionInfo == null)
+                {
+                    // can't find the Home region: Tell viewer and abort
+                    client.SendTeleportFailed("Your home region could not be found.");
+                    return;
+                }
+                // a little eekie that this goes back to Scene and with a forced cast, will fix that at some point...
+                ((Scene)(client.Scene)).RequestTeleportLocation(
+                    client, regionInfo.RegionHandle, pinfo.HomePosition, pinfo.HomeLookAt,
+                    (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaHome));
+            }
+        }
+
+        #endregion
+
+
+        #region Agent Crossings
+
+        public void Cross(ScenePresence agent, bool isFlying)
+        {
+            Scene scene = agent.Scene;
+            Vector3 pos = agent.AbsolutePosition;
+            Vector3 newpos = new Vector3(pos.X, pos.Y, pos.Z);
+            uint neighbourx = scene.RegionInfo.RegionLocX;
+            uint neighboury = scene.RegionInfo.RegionLocY;
+            const float boundaryDistance = 1.7f;
+            Vector3 northCross = new Vector3(0, boundaryDistance, 0);
+            Vector3 southCross = new Vector3(0, -1 * boundaryDistance, 0);
+            Vector3 eastCross = new Vector3(boundaryDistance, 0, 0);
+            Vector3 westCross = new Vector3(-1 * boundaryDistance, 0, 0);
+
+            // distance to edge that will trigger crossing
+
+
+            // distance into new region to place avatar
+            const float enterDistance = 0.5f;
+
+            if (scene.TestBorderCross(pos + westCross, Cardinals.W))
+            {
+                if (scene.TestBorderCross(pos + northCross, Cardinals.N))
+                {
+                    Border b = scene.GetCrossedBorder(pos + northCross, Cardinals.N);
+                    neighboury += (uint)(int)(b.BorderLine.Z / (int)Constants.RegionSize);
+                }
+                else if (scene.TestBorderCross(pos + southCross, Cardinals.S))
+                {
+                    Border b = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
+                    if (b.TriggerRegionX == 0 && b.TriggerRegionY == 0)
+                    {
+                        neighboury--;
+                        newpos.Y = Constants.RegionSize - enterDistance;
+                    }
+                    else
+                    {
+                        neighboury = b.TriggerRegionY;
+                        neighbourx = b.TriggerRegionX;
+
+                        Vector3 newposition = pos;
+                        newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
+                        newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
+                        agent.ControllingClient.SendAgentAlertMessage(
+                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
+                        InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
+                        return;
+                    }
+                }
+
+                Border ba = scene.GetCrossedBorder(pos + westCross, Cardinals.W);
+                if (ba.TriggerRegionX == 0 && ba.TriggerRegionY == 0)
+                {
+                    neighbourx--;
+                    newpos.X = Constants.RegionSize - enterDistance;
+                }
+                else
+                {
+                    neighboury = ba.TriggerRegionY;
+                    neighbourx = ba.TriggerRegionX;
+
+
+                    Vector3 newposition = pos;
+                    newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
+                    newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
+                    agent.ControllingClient.SendAgentAlertMessage(
+                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
+                    InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
+
+
+                    return;
+                }
+
+            }
+            else if (scene.TestBorderCross(pos + eastCross, Cardinals.E))
+            {
+                Border b = scene.GetCrossedBorder(pos + eastCross, Cardinals.E);
+                neighbourx += (uint)(int)(b.BorderLine.Z / (int)Constants.RegionSize);
+                newpos.X = enterDistance;
+
+                if (scene.TestBorderCross(pos + southCross, Cardinals.S))
+                {
+                    Border ba = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
+                    if (ba.TriggerRegionX == 0 && ba.TriggerRegionY == 0)
+                    {
+                        neighboury--;
+                        newpos.Y = Constants.RegionSize - enterDistance;
+                    }
+                    else
+                    {
+                        neighboury = ba.TriggerRegionY;
+                        neighbourx = ba.TriggerRegionX;
+                        Vector3 newposition = pos;
+                        newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
+                        newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
+                        agent.ControllingClient.SendAgentAlertMessage(
+                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
+                        InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
+                        return;
+                    }
+                }
+                else if (scene.TestBorderCross(pos + northCross, Cardinals.N))
+                {
+                    Border c = scene.GetCrossedBorder(pos + northCross, Cardinals.N);
+                    neighboury += (uint)(int)(c.BorderLine.Z / (int)Constants.RegionSize);
+                    newpos.Y = enterDistance;
+                }
+
+
+            }
+            else if (scene.TestBorderCross(pos + southCross, Cardinals.S))
+            {
+                Border b = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
+                if (b.TriggerRegionX == 0 && b.TriggerRegionY == 0)
+                {
+                    neighboury--;
+                    newpos.Y = Constants.RegionSize - enterDistance;
+                }
+                else
+                {
+                    neighboury = b.TriggerRegionY;
+                    neighbourx = b.TriggerRegionX;
+                    Vector3 newposition = pos;
+                    newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
+                    newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
+                    agent.ControllingClient.SendAgentAlertMessage(
+                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
+                    InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
+                    return;
+                }
+            }
+            else if (scene.TestBorderCross(pos + northCross, Cardinals.N))
+            {
+
+                Border b = scene.GetCrossedBorder(pos + northCross, Cardinals.N);
+                neighboury += (uint)(int)(b.BorderLine.Z / (int)Constants.RegionSize);
+                newpos.Y = enterDistance;
+            }
+
+            /*
+
+            if (pos.X < boundaryDistance) //West
+            {
+                neighbourx--;
+                newpos.X = Constants.RegionSize - enterDistance;
+            }
+            else if (pos.X > Constants.RegionSize - boundaryDistance) // East
+            {
+                neighbourx++;
+                newpos.X = enterDistance;
+            }
+
+            if (pos.Y < boundaryDistance) // South
+            {
+                neighboury--;
+                newpos.Y = Constants.RegionSize - enterDistance;
+            }
+            else if (pos.Y > Constants.RegionSize - boundaryDistance) // North
+            {
+                neighboury++;
+                newpos.Y = enterDistance;
+            }
+            */
+
+            CrossAgentToNewRegionDelegate d = CrossAgentToNewRegionAsync;
+            d.BeginInvoke(agent, newpos, neighbourx, neighboury, isFlying, CrossAgentToNewRegionCompleted, d);
+
+        }
+
+
+        public delegate void InformClientToInitateTeleportToLocationDelegate(ScenePresence agent, uint regionX, uint regionY,
+                                                            Vector3 position,
+                                                            Scene initiatingScene);
+
+        private void InformClientToInitateTeleportToLocation(ScenePresence agent, uint regionX, uint regionY, Vector3 position, Scene initiatingScene)
+        {
+
+            // This assumes that we know what our neighbors are.
+
+            InformClientToInitateTeleportToLocationDelegate d = InformClientToInitiateTeleportToLocationAsync;
+            d.BeginInvoke(agent, regionX, regionY, position, initiatingScene,
+                          InformClientToInitiateTeleportToLocationCompleted,
+                          d);
+        }
+
+        public void InformClientToInitiateTeleportToLocationAsync(ScenePresence agent, uint regionX, uint regionY, Vector3 position,
+            Scene initiatingScene)
+        {
+            Thread.Sleep(10000);
+            IMessageTransferModule im = initiatingScene.RequestModuleInterface<IMessageTransferModule>();
+            if (im != null)
+            {
+                UUID gotoLocation = Util.BuildFakeParcelID(
+                    Util.UIntsToLong(
+                                              (regionX *
+                                               (uint)Constants.RegionSize),
+                                              (regionY *
+                                               (uint)Constants.RegionSize)),
+                    (uint)(int)position.X,
+                    (uint)(int)position.Y,
+                    (uint)(int)position.Z);
+                GridInstantMessage m = new GridInstantMessage(initiatingScene, UUID.Zero,
+                "Region", agent.UUID,
+                (byte)InstantMessageDialog.GodLikeRequestTeleport, false,
+                "", gotoLocation, false, new Vector3(127, 0, 0),
+                new Byte[0]);
+                im.SendInstantMessage(m, delegate(bool success)
+                {
+                    m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Client Initiating Teleport sending IM success = {0}", success);
+                });
+
+            }
+        }
+
+        private void InformClientToInitiateTeleportToLocationCompleted(IAsyncResult iar)
+        {
+            InformClientToInitateTeleportToLocationDelegate icon =
+                (InformClientToInitateTeleportToLocationDelegate)iar.AsyncState;
+            icon.EndInvoke(iar);
+        }
+
+        public delegate ScenePresence CrossAgentToNewRegionDelegate(ScenePresence agent, Vector3 pos, uint neighbourx, uint neighboury, bool isFlying);
+
+        /// <summary>
+        /// This Closes child agents on neighboring regions
+        /// Calls an asynchronous method to do so..  so it doesn't lag the sim.
+        /// </summary>
+        protected ScenePresence CrossAgentToNewRegionAsync(ScenePresence agent, Vector3 pos, uint neighbourx, uint neighboury, bool isFlying)
+        {
+            m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Crossing agent {0} {1} to {2}-{3}", agent.Firstname, agent.Lastname, neighbourx, neighboury);
+
+            Scene m_scene = agent.Scene;
+            ulong neighbourHandle = Utils.UIntsToLong((uint)(neighbourx * Constants.RegionSize), (uint)(neighboury * Constants.RegionSize));
+
+            int x = (int)(neighbourx * Constants.RegionSize), y = (int)(neighboury * Constants.RegionSize);
+            GridRegion neighbourRegion = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y);
+
+            if (neighbourRegion != null && agent.ValidateAttachments())
+            {
+                pos = pos + (agent.Velocity);
+
+                SetInTransit(agent.UUID);
+                AgentData cAgent = new AgentData();
+                agent.CopyTo(cAgent);
+                cAgent.Position = pos;
+                if (isFlying)
+                    cAgent.ControlFlags |= (uint)AgentManager.ControlFlags.AGENT_CONTROL_FLY;
+                cAgent.CallbackURI = "http://" + m_scene.RegionInfo.ExternalHostName + ":" + m_scene.RegionInfo.HttpPort +
+                    "/agent/" + agent.UUID.ToString() + "/" + m_scene.RegionInfo.RegionID.ToString() + "/release/";
+
+                m_scene.SimulationService.UpdateAgent(neighbourRegion, cAgent);
+
+                // Next, let's close the child agent connections that are too far away.
+                agent.CloseChildAgents(neighbourx, neighboury);
+
+                //AgentCircuitData circuitdata = m_controllingClient.RequestClientInfo();
+                agent.ControllingClient.RequestClientInfo();
+
+                //m_log.Debug("BEFORE CROSS");
+                //Scene.DumpChildrenSeeds(UUID);
+                //DumpKnownRegions();
+                string agentcaps;
+                if (!agent.KnownRegions.TryGetValue(neighbourRegion.RegionHandle, out agentcaps))
+                {
+                    m_log.ErrorFormat("[ENTITY TRANSFER MODULE]: No ENTITY TRANSFER MODULE information for region handle {0}, exiting CrossToNewRegion.",
+                                     neighbourRegion.RegionHandle);
+                    return agent;
+                }
+                // TODO Should construct this behind a method
+                string capsPath =
+                    "http://" + neighbourRegion.ExternalHostName + ":" + neighbourRegion.HttpPort
+                     + "/CAPS/" + agentcaps /*circuitdata.CapsPath*/ + "0000/";
+
+                m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} to client {1}", capsPath, agent.UUID);
+
+                IEventQueue eq = agent.Scene.RequestModuleInterface<IEventQueue>();
+                if (eq != null)
+                {
+                    eq.CrossRegion(neighbourHandle, pos, agent.Velocity, neighbourRegion.ExternalEndPoint,
+                                   capsPath, agent.UUID, agent.ControllingClient.SessionId);
+                }
+                else
+                {
+                    agent.ControllingClient.CrossRegion(neighbourHandle, pos, agent.Velocity, neighbourRegion.ExternalEndPoint,
+                                                capsPath);
+                }
+
+                if (!WaitForCallback(agent.UUID))
+                {
+                    m_log.Debug("[ENTITY TRANSFER MODULE]: Callback never came in crossing agent");
+                    ResetFromTransit(agent.UUID);
+
+                    // Yikes! We should just have a ref to scene here.
+                    //agent.Scene.InformClientOfNeighbours(agent);
+                    EnableChildAgents(agent);
+
+                    return agent;
+                }
+
+                agent.MakeChildAgent();
+                // now we have a child agent in this region. Request all interesting data about other (root) agents
+                agent.SendInitialFullUpdateToAllClients();
+
+                CrossAttachmentsIntoNewRegion(neighbourRegion, agent, true);
+
+                //                    m_scene.SendKillObject(m_localId);
+
+                agent.Scene.NotifyMyCoarseLocationChange();
+                // the user may change their profile information in other region,
+                // so the userinfo in UserProfileCache is not reliable any more, delete it
+                // REFACTORING PROBLEM. Well, not a problem, but this method is HORRIBLE!
+                if (agent.Scene.NeedSceneCacheClear(agent.UUID))
+                {
+                    m_log.DebugFormat(
+                        "[ENTITY TRANSFER MODULE]: User {0} is going to another region", agent.UUID);
+                }
+            }
+
+            //m_log.Debug("AFTER CROSS");
+            //Scene.DumpChildrenSeeds(UUID);
+            //DumpKnownRegions();
+            return agent;
+        }
+
+        private void CrossAgentToNewRegionCompleted(IAsyncResult iar)
+        {
+            CrossAgentToNewRegionDelegate icon = (CrossAgentToNewRegionDelegate)iar.AsyncState;
+            ScenePresence agent = icon.EndInvoke(iar);
+
+            // If the cross was successful, this agent is a child agent
+            if (agent.IsChildAgent)
+                agent.Reset();
+            else // Not successful
+                agent.RestoreInCurrentScene();
+
+            // In any case
+            agent.NotInTransit();
+
+            //m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Crossing agent {0} {1} completed.", agent.Firstname, agent.Lastname);
+        }
+
+        #endregion
+
+        #region Enable Child Agent
+        /// <summary>
+        /// This informs a single neighboring region about agent "avatar".
+        /// Calls an asynchronous method to do so..  so it doesn't lag the sim.
+        /// </summary>
+        public void EnableChildAgent(ScenePresence sp, GridRegion region)
+        {
+            AgentCircuitData agent = sp.ControllingClient.RequestClientInfo();
+            agent.BaseFolder = UUID.Zero;
+            agent.InventoryFolder = UUID.Zero;
+            agent.startpos = new Vector3(128, 128, 70);
+            agent.child = true;
+            agent.Appearance = sp.Appearance;
+
+            InformClientOfNeighbourDelegate d = InformClientOfNeighbourAsync;
+            d.BeginInvoke(sp, agent, region, region.ExternalEndPoint, true,
+                          InformClientOfNeighbourCompleted,
+                          d);
+        }
+        #endregion
+
+        #region Enable Child Agents
+
+        private delegate void InformClientOfNeighbourDelegate(
+            ScenePresence avatar, AgentCircuitData a, GridRegion reg, IPEndPoint endPoint, bool newAgent);
+
+        /// <summary>
+        /// This informs all neighboring regions about agent "avatar".
+        /// Calls an asynchronous method to do so..  so it doesn't lag the sim.
+        /// </summary>
+        public void EnableChildAgents(ScenePresence sp)
+        {
+            List<GridRegion> neighbours = new List<GridRegion>();
+            RegionInfo m_regionInfo = sp.Scene.RegionInfo;
+
+            if (m_regionInfo != null)
+            {
+                neighbours = RequestNeighbours(sp.Scene, m_regionInfo.RegionLocX, m_regionInfo.RegionLocY);
+            }
+            else
+            {
+                m_log.Debug("[ENTITY TRANSFER MODULE]: m_regionInfo was null in EnableChildAgents, is this a NPC?");
+            }
+
+            /// We need to find the difference between the new regions where there are no child agents
+            /// and the regions where there are already child agents. We only send notification to the former.
+            List<ulong> neighbourHandles = NeighbourHandles(neighbours); // on this region
+            neighbourHandles.Add(sp.Scene.RegionInfo.RegionHandle);  // add this region too
+            List<ulong> previousRegionNeighbourHandles;
+
+            if (sp.Scene.CapsModule != null)
+            {
+                previousRegionNeighbourHandles =
+                    new List<ulong>(sp.Scene.CapsModule.GetChildrenSeeds(sp.UUID).Keys);
+            }
+            else
+            {
+                previousRegionNeighbourHandles = new List<ulong>();
+            }
+
+            List<ulong> newRegions = NewNeighbours(neighbourHandles, previousRegionNeighbourHandles);
+            List<ulong> oldRegions = OldNeighbours(neighbourHandles, previousRegionNeighbourHandles);
+
+            //Dump("Current Neighbors", neighbourHandles);
+            //Dump("Previous Neighbours", previousRegionNeighbourHandles);
+            //Dump("New Neighbours", newRegions);
+            //Dump("Old Neighbours", oldRegions);
+
+            /// Update the scene presence's known regions here on this region
+            sp.DropOldNeighbours(oldRegions);
+
+            /// Collect as many seeds as possible
+            Dictionary<ulong, string> seeds;
+            if (sp.Scene.CapsModule != null)
+                seeds
+                    = new Dictionary<ulong, string>(sp.Scene.CapsModule.GetChildrenSeeds(sp.UUID));
+            else
+                seeds = new Dictionary<ulong, string>();
+
+            //m_log.Debug(" !!! No. of seeds: " + seeds.Count);
+            if (!seeds.ContainsKey(sp.Scene.RegionInfo.RegionHandle))
+                seeds.Add(sp.Scene.RegionInfo.RegionHandle, sp.ControllingClient.RequestClientInfo().CapsPath);
+
+            /// Create the necessary child agents
+            List<AgentCircuitData> cagents = new List<AgentCircuitData>();
+            foreach (GridRegion neighbour in neighbours)
+            {
+                if (neighbour.RegionHandle != sp.Scene.RegionInfo.RegionHandle)
+                {
+
+                    AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
+                    AgentCircuitData agent = sp.ControllingClient.RequestClientInfo();
+                    agent.BaseFolder = UUID.Zero;
+                    agent.InventoryFolder = UUID.Zero;
+                    agent.startpos = new Vector3(128, 128, 70);
+                    agent.child = true;
+                    agent.Appearance = sp.Appearance;
+                    if (currentAgentCircuit != null)
+                        agent.ServiceURLs = currentAgentCircuit.ServiceURLs;
+
+                    if (newRegions.Contains(neighbour.RegionHandle))
+                    {
+                        agent.CapsPath = CapsUtil.GetRandomCapsObjectPath();
+                        sp.AddNeighbourRegion(neighbour.RegionHandle, agent.CapsPath);
+                        seeds.Add(neighbour.RegionHandle, agent.CapsPath);
+                    }
+                    else
+                        agent.CapsPath = sp.Scene.CapsModule.GetChildSeed(sp.UUID, neighbour.RegionHandle);
+
+                    cagents.Add(agent);
+                }
+            }
+
+            /// Update all child agent with everyone's seeds
+            foreach (AgentCircuitData a in cagents)
+            {
+                a.ChildrenCapSeeds = new Dictionary<ulong, string>(seeds);
+            }
+
+            if (sp.Scene.CapsModule != null)
+            {
+                sp.Scene.CapsModule.SetChildrenSeed(sp.UUID, seeds);
+            }
+            sp.KnownRegions = seeds;
+            //avatar.Scene.DumpChildrenSeeds(avatar.UUID);
+            //avatar.DumpKnownRegions();
+
+            bool newAgent = false;
+            int count = 0;
+            foreach (GridRegion neighbour in neighbours)
+            {
+                //m_log.WarnFormat("--> Going to send child agent to {0}", neighbour.RegionName);
+                // Don't do it if there's already an agent in that region
+                if (newRegions.Contains(neighbour.RegionHandle))
+                    newAgent = true;
+                else
+                    newAgent = false;
+
+                if (neighbour.RegionHandle != sp.Scene.RegionInfo.RegionHandle)
+                {
+                    InformClientOfNeighbourDelegate d = InformClientOfNeighbourAsync;
+                    try
+                    {
+                        d.BeginInvoke(sp, cagents[count], neighbour, neighbour.ExternalEndPoint, newAgent,
+                                      InformClientOfNeighbourCompleted,
+                                      d);
+                    }
+
+                    catch (ArgumentOutOfRangeException)
+                    {
+                        m_log.ErrorFormat(
+                           "[ENTITY TRANSFER MODULE]: Neighbour Regions response included the current region in the neighbor list.  The following region will not display to the client: {0} for region {1} ({2}, {3}).",
+                           neighbour.ExternalHostName,
+                           neighbour.RegionHandle,
+                           neighbour.RegionLocX,
+                           neighbour.RegionLocY);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[ENTITY TRANSFER MODULE]: Could not resolve external hostname {0} for region {1} ({2}, {3}).  {4}",
+                            neighbour.ExternalHostName,
+                            neighbour.RegionHandle,
+                            neighbour.RegionLocX,
+                            neighbour.RegionLocY,
+                            e);
+
+                        // FIXME: Okay, even though we've failed, we're still going to throw the exception on,
+                        // since I don't know what will happen if we just let the client continue
+
+                        // XXX: Well, decided to swallow the exception instead for now.  Let us see how that goes.
+                        // throw e;
+
+                    }
+                }
+                count++;
+            }
+        }
+
+        private void InformClientOfNeighbourCompleted(IAsyncResult iar)
+        {
+            InformClientOfNeighbourDelegate icon = (InformClientOfNeighbourDelegate)iar.AsyncState;
+            icon.EndInvoke(iar);
+            //m_log.WarnFormat(" --> InformClientOfNeighbourCompleted");
+        }
+
+        /// <summary>
+        /// Async component for informing client of which neighbours exist
+        /// </summary>
+        /// <remarks>
+        /// This needs to run asynchronously, as a network timeout may block the thread for a long while
+        /// </remarks>
+        /// <param name="remoteClient"></param>
+        /// <param name="a"></param>
+        /// <param name="regionHandle"></param>
+        /// <param name="endPoint"></param>
+        private void InformClientOfNeighbourAsync(ScenePresence sp, AgentCircuitData a, GridRegion reg,
+                                                  IPEndPoint endPoint, bool newAgent)
+        {
+            // Let's wait just a little to give time to originating regions to catch up with closing child agents
+            // after a cross here
+            Thread.Sleep(500);
+
+            Scene m_scene = sp.Scene;
+
+            uint x, y;
+            Utils.LongToUInts(reg.RegionHandle, out x, out y);
+            x = x / Constants.RegionSize;
+            y = y / Constants.RegionSize;
+            m_log.Info("[ENTITY TRANSFER MODULE]: Starting to inform client about neighbour " + x + ", " + y + "(" + endPoint.ToString() + ")");
+
+            string capsPath = "http://" + reg.ExternalHostName + ":" + reg.HttpPort
+                  + "/CAPS/" + a.CapsPath + "0000/";
+
+            string reason = String.Empty;
+
+
+            bool regionAccepted = m_scene.SimulationService.CreateAgent(reg, a, 0, out reason); // m_interregionCommsOut.SendCreateChildAgent(reg.RegionHandle, a, 0, out reason);
+
+            if (regionAccepted && newAgent)
+            {
+                IEventQueue eq = sp.Scene.RequestModuleInterface<IEventQueue>();
+                if (eq != null)
+                {
+                    #region IP Translation for NAT
+                    IClientIPEndpoint ipepClient;
+                    if (sp.ClientView.TryGet(out ipepClient))
+                    {
+                        endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
+                    }
+                    #endregion
+
+                    m_log.DebugFormat("[ENTITY TRANSFER MODULE]: {0} is sending {1} EnableSimulator for neighbor region {2} @ {3} " +
+                        "and EstablishAgentCommunication with seed cap {4}",
+                        m_scene.RegionInfo.RegionName, sp.Name, reg.RegionName, reg.RegionHandle, capsPath);
+
+                    eq.EnableSimulator(reg.RegionHandle, endPoint, sp.UUID);
+                    eq.EstablishAgentCommunication(sp.UUID, endPoint, capsPath);
+                }
+                else
+                {
+                    sp.ControllingClient.InformClientOfNeighbour(reg.RegionHandle, endPoint);
+                    // TODO: make Event Queue disablable!
+                }
+
+                m_log.Info("[ENTITY TRANSFER MODULE]: Completed inform client about neighbour " + endPoint.ToString());
+
+            }
+
+        }
+
+        protected List<GridRegion> RequestNeighbours(Scene pScene, uint pRegionLocX, uint pRegionLocY)
+        {
+            RegionInfo m_regionInfo = pScene.RegionInfo;
+
+            Border[] northBorders = pScene.NorthBorders.ToArray();
+            Border[] southBorders = pScene.SouthBorders.ToArray();
+            Border[] eastBorders = pScene.EastBorders.ToArray();
+            Border[] westBorders = pScene.WestBorders.ToArray();
+
+            // Legacy one region.  Provided for simplicity while testing the all inclusive method in the else statement.
+            if (northBorders.Length <= 1 && southBorders.Length <= 1 && eastBorders.Length <= 1 && westBorders.Length <= 1)
+            {
+                return pScene.GridService.GetNeighbours(m_regionInfo.ScopeID, m_regionInfo.RegionID);
+            }
+            else
+            {
+                Vector2 extent = Vector2.Zero;
+                for (int i = 0; i < eastBorders.Length; i++)
+                {
+                    extent.X = (eastBorders[i].BorderLine.Z > extent.X) ? eastBorders[i].BorderLine.Z : extent.X;
+                }
+                for (int i = 0; i < northBorders.Length; i++)
+                {
+                    extent.Y = (northBorders[i].BorderLine.Z > extent.Y) ? northBorders[i].BorderLine.Z : extent.Y;
+                }
+
+                // Loss of fraction on purpose
+                extent.X = ((int)extent.X / (int)Constants.RegionSize) + 1;
+                extent.Y = ((int)extent.Y / (int)Constants.RegionSize) + 1;
+
+                int startX = (int)(pRegionLocX - 1) * (int)Constants.RegionSize;
+                int startY = (int)(pRegionLocY - 1) * (int)Constants.RegionSize;
+
+                int endX = ((int)pRegionLocX + (int)extent.X) * (int)Constants.RegionSize;
+                int endY = ((int)pRegionLocY + (int)extent.Y) * (int)Constants.RegionSize;
+
+                List<GridRegion> neighbours = pScene.GridService.GetRegionRange(m_regionInfo.ScopeID, startX, endX, startY, endY);
+                neighbours.RemoveAll(delegate(GridRegion r) { return r.RegionID == m_regionInfo.RegionID; });
+
+                return neighbours;
+            }
+        }
+
+        private List<ulong> NewNeighbours(List<ulong> currentNeighbours, List<ulong> previousNeighbours)
+        {
+            return currentNeighbours.FindAll(delegate(ulong handle) { return !previousNeighbours.Contains(handle); });
+        }
+
+        //        private List<ulong> CommonNeighbours(List<ulong> currentNeighbours, List<ulong> previousNeighbours)
+        //        {
+        //            return currentNeighbours.FindAll(delegate(ulong handle) { return previousNeighbours.Contains(handle); });
+        //        }
+
+        private List<ulong> OldNeighbours(List<ulong> currentNeighbours, List<ulong> previousNeighbours)
+        {
+            return previousNeighbours.FindAll(delegate(ulong handle) { return !currentNeighbours.Contains(handle); });
+        }
+
+        private List<ulong> NeighbourHandles(List<GridRegion> neighbours)
+        {
+            List<ulong> handles = new List<ulong>();
+            foreach (GridRegion reg in neighbours)
+            {
+                handles.Add(reg.RegionHandle);
+            }
+            return handles;
+        }
+
+        private void Dump(string msg, List<ulong> handles)
+        {
+            m_log.InfoFormat("-------------- HANDLE DUMP ({0}) ---------", msg);
+            foreach (ulong handle in handles)
+            {
+                uint x, y;
+                Utils.LongToUInts(handle, out x, out y);
+                x = x / Constants.RegionSize;
+                y = y / Constants.RegionSize;
+                m_log.InfoFormat("({0}, {1})", x, y);
+            }
+        }
+
+        #endregion
+
+
+        #region Agent Arrived
+        public void AgentArrivedAtDestination(UUID id)
+        {
+            //m_log.Debug(" >>> ReleaseAgent called <<< ");
+            ResetFromTransit(id);
+        }
+
+        #endregion
+
+        #region Object Transfers
+        /// <summary>
+        /// Move the given scene object into a new region depending on which region its absolute position has moved
+        /// into.
+        ///
+        /// This method locates the new region handle and offsets the prim position for the new region
+        /// </summary>
+        /// <param name="attemptedPosition">the attempted out of region position of the scene object</param>
+        /// <param name="grp">the scene object that we're crossing</param>
+        public void Cross(SceneObjectGroup grp, Vector3 attemptedPosition, bool silent)
+        {
+            if (grp == null)
+                return;
+            if (grp.IsDeleted)
+                return;
+
+            Scene scene = grp.Scene;
+            if (scene == null)
+                return;
+
+            if (grp.RootPart.DIE_AT_EDGE)
+            {
+                // We remove the object here
+                try
+                {
+                    scene.DeleteSceneObject(grp, false);
+                }
+                catch (Exception)
+                {
+                    m_log.Warn("[DATABASE]: exception when trying to remove the prim that crossed the border.");
+                }
+                return;
+            }
+
+            int thisx = (int)scene.RegionInfo.RegionLocX;
+            int thisy = (int)scene.RegionInfo.RegionLocY;
+            Vector3 EastCross = new Vector3(0.1f, 0, 0);
+            Vector3 WestCross = new Vector3(-0.1f, 0, 0);
+            Vector3 NorthCross = new Vector3(0, 0.1f, 0);
+            Vector3 SouthCross = new Vector3(0, -0.1f, 0);
+
+
+            // use this if no borders were crossed!
+            ulong newRegionHandle
+                        = Util.UIntsToLong((uint)((thisx) * Constants.RegionSize),
+                                           (uint)((thisy) * Constants.RegionSize));
+
+            Vector3 pos = attemptedPosition;
+
+            int changeX = 1;
+            int changeY = 1;
+
+            if (scene.TestBorderCross(attemptedPosition + WestCross, Cardinals.W))
+            {
+                if (scene.TestBorderCross(attemptedPosition + SouthCross, Cardinals.S))
+                {
+
+                    Border crossedBorderx = scene.GetCrossedBorder(attemptedPosition + WestCross, Cardinals.W);
+
+                    if (crossedBorderx.BorderLine.Z > 0)
+                    {
+                        pos.X = ((pos.X + crossedBorderx.BorderLine.Z));
+                        changeX = (int)(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize);
+                    }
+                    else
+                        pos.X = ((pos.X + Constants.RegionSize));
+
+                    Border crossedBordery = scene.GetCrossedBorder(attemptedPosition + SouthCross, Cardinals.S);
+                    //(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize)
+
+                    if (crossedBordery.BorderLine.Z > 0)
+                    {
+                        pos.Y = ((pos.Y + crossedBordery.BorderLine.Z));
+                        changeY = (int)(crossedBordery.BorderLine.Z / (int)Constants.RegionSize);
+                    }
+                    else
+                        pos.Y = ((pos.Y + Constants.RegionSize));
+
+
+
+                    newRegionHandle
+                        = Util.UIntsToLong((uint)((thisx - changeX) * Constants.RegionSize),
+                                           (uint)((thisy - changeY) * Constants.RegionSize));
+                    // x - 1
+                    // y - 1
+                }
+                else if (scene.TestBorderCross(attemptedPosition + NorthCross, Cardinals.N))
+                {
+                    Border crossedBorderx = scene.GetCrossedBorder(attemptedPosition + WestCross, Cardinals.W);
+
+                    if (crossedBorderx.BorderLine.Z > 0)
+                    {
+                        pos.X = ((pos.X + crossedBorderx.BorderLine.Z));
+                        changeX = (int)(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize);
+                    }
+                    else
+                        pos.X = ((pos.X + Constants.RegionSize));
+
+
+                    Border crossedBordery = scene.GetCrossedBorder(attemptedPosition + SouthCross, Cardinals.S);
+                    //(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize)
+
+                    if (crossedBordery.BorderLine.Z > 0)
+                    {
+                        pos.Y = ((pos.Y + crossedBordery.BorderLine.Z));
+                        changeY = (int)(crossedBordery.BorderLine.Z / (int)Constants.RegionSize);
+                    }
+                    else
+                        pos.Y = ((pos.Y + Constants.RegionSize));
+
+                    newRegionHandle
+                        = Util.UIntsToLong((uint)((thisx - changeX) * Constants.RegionSize),
+                                           (uint)((thisy + changeY) * Constants.RegionSize));
+                    // x - 1
+                    // y + 1
+                }
+                else
+                {
+                    Border crossedBorderx = scene.GetCrossedBorder(attemptedPosition + WestCross, Cardinals.W);
+
+                    if (crossedBorderx.BorderLine.Z > 0)
+                    {
+                        pos.X = ((pos.X + crossedBorderx.BorderLine.Z));
+                        changeX = (int)(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize);
+                    }
+                    else
+                        pos.X = ((pos.X + Constants.RegionSize));
+
+                    newRegionHandle
+                        = Util.UIntsToLong((uint)((thisx - changeX) * Constants.RegionSize),
+                                           (uint)(thisy * Constants.RegionSize));
+                    // x - 1
+                }
+            }
+            else if (scene.TestBorderCross(attemptedPosition + EastCross, Cardinals.E))
+            {
+                if (scene.TestBorderCross(attemptedPosition + SouthCross, Cardinals.S))
+                {
+
+                    pos.X = ((pos.X - Constants.RegionSize));
+                    Border crossedBordery = scene.GetCrossedBorder(attemptedPosition + SouthCross, Cardinals.S);
+                    //(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize)
+
+                    if (crossedBordery.BorderLine.Z > 0)
+                    {
+                        pos.Y = ((pos.Y + crossedBordery.BorderLine.Z));
+                        changeY = (int)(crossedBordery.BorderLine.Z / (int)Constants.RegionSize);
+                    }
+                    else
+                        pos.Y = ((pos.Y + Constants.RegionSize));
+
+
+                    newRegionHandle
+                        = Util.UIntsToLong((uint)((thisx + changeX) * Constants.RegionSize),
+                                           (uint)((thisy - changeY) * Constants.RegionSize));
+                    // x + 1
+                    // y - 1
+                }
+                else if (scene.TestBorderCross(attemptedPosition + NorthCross, Cardinals.N))
+                {
+                    pos.X = ((pos.X - Constants.RegionSize));
+                    pos.Y = ((pos.Y - Constants.RegionSize));
+                    newRegionHandle
+                        = Util.UIntsToLong((uint)((thisx + changeX) * Constants.RegionSize),
+                                           (uint)((thisy + changeY) * Constants.RegionSize));
+                    // x + 1
+                    // y + 1
+                }
+                else
+                {
+                    pos.X = ((pos.X - Constants.RegionSize));
+                    newRegionHandle
+                        = Util.UIntsToLong((uint)((thisx + changeX) * Constants.RegionSize),
+                                           (uint)(thisy * Constants.RegionSize));
+                    // x + 1
+                }
+            }
+            else if (scene.TestBorderCross(attemptedPosition + SouthCross, Cardinals.S))
+            {
+                Border crossedBordery = scene.GetCrossedBorder(attemptedPosition + SouthCross, Cardinals.S);
+                //(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize)
+
+                if (crossedBordery.BorderLine.Z > 0)
+                {
+                    pos.Y = ((pos.Y + crossedBordery.BorderLine.Z));
+                    changeY = (int)(crossedBordery.BorderLine.Z / (int)Constants.RegionSize);
+                }
+                else
+                    pos.Y = ((pos.Y + Constants.RegionSize));
+
+                newRegionHandle
+                    = Util.UIntsToLong((uint)(thisx * Constants.RegionSize), (uint)((thisy - changeY) * Constants.RegionSize));
+                // y - 1
+            }
+            else if (scene.TestBorderCross(attemptedPosition + NorthCross, Cardinals.N))
+            {
+
+                pos.Y = ((pos.Y - Constants.RegionSize));
+                newRegionHandle
+                    = Util.UIntsToLong((uint)(thisx * Constants.RegionSize), (uint)((thisy + changeY) * Constants.RegionSize));
+                // y + 1
+            }
+
+            // Offset the positions for the new region across the border
+            Vector3 oldGroupPosition = grp.RootPart.GroupPosition;
+            grp.OffsetForNewRegion(pos);
+
+            // If we fail to cross the border, then reset the position of the scene object on that border.
+            uint x = 0, y = 0;
+            Utils.LongToUInts(newRegionHandle, out x, out y);
+            GridRegion destination = scene.GridService.GetRegionByPosition(UUID.Zero, (int)x, (int)y);
+            if (destination != null && !CrossPrimGroupIntoNewRegion(destination, grp, silent))
+            {
+                grp.OffsetForNewRegion(oldGroupPosition);
+                grp.ScheduleGroupForFullUpdate();
+            }
+        }
+
+
+        /// <summary>
+        /// Move the given scene object into a new region
+        /// </summary>
+        /// <param name="newRegionHandle"></param>
+        /// <param name="grp">Scene Object Group that we're crossing</param>
+        /// <returns>
+        /// true if the crossing itself was successful, false on failure
+        /// FIMXE: we still return true if the crossing object was not successfully deleted from the originating region
+        /// </returns>
+        protected bool CrossPrimGroupIntoNewRegion(GridRegion destination, SceneObjectGroup grp, bool silent)
+        {
+            //m_log.Debug("  >>> CrossPrimGroupIntoNewRegion <<<");
+
+            bool successYN = false;
+            grp.RootPart.UpdateFlag = 0;
+            //int primcrossingXMLmethod = 0;
+
+            if (destination != null)
+            {
+                //string objectState = grp.GetStateSnapshot();
+
+                //successYN
+                //    = m_sceneGridService.PrimCrossToNeighboringRegion(
+                //        newRegionHandle, grp.UUID, m_serialiser.SaveGroupToXml2(grp), primcrossingXMLmethod);
+                //if (successYN && (objectState != "") && m_allowScriptCrossings)
+                //{
+                //    successYN = m_sceneGridService.PrimCrossToNeighboringRegion(
+                //            newRegionHandle, grp.UUID, objectState, 100);
+                //}
+
+                //// And the new channel...
+                //if (m_interregionCommsOut != null)
+                //    successYN = m_interregionCommsOut.SendCreateObject(newRegionHandle, grp, true);
+                if (m_aScene.SimulationService != null)
+                    successYN = m_aScene.SimulationService.CreateObject(destination, grp, true);
+
+                if (successYN)
+                {
+                    // We remove the object here
+                    try
+                    {
+                        grp.Scene.DeleteSceneObject(grp, silent);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[ENTITY TRANSFER MODULE]: Exception deleting the old object left behind on a border crossing for {0}, {1}",
+                            grp, e);
+                    }
+                }
+                else
+                {
+                    if (!grp.IsDeleted)
+                    {
+                        if (grp.RootPart.PhysActor != null)
+                        {
+                            grp.RootPart.PhysActor.CrossingFailure();
+                        }
+                    }
+
+                    m_log.ErrorFormat("[ENTITY TRANSFER MODULE]: Prim crossing failed for {0}", grp);
+                }
+            }
+            else
+            {
+                m_log.Error("[ENTITY TRANSFER MODULE]: destination was unexpectedly null in Scene.CrossPrimGroupIntoNewRegion()");
+            }
+
+            return successYN;
+        }
+
+        protected bool CrossAttachmentsIntoNewRegion(GridRegion destination, ScenePresence sp, bool silent)
+        {
+            List<SceneObjectGroup> m_attachments = sp.Attachments;
+            lock (m_attachments)
+            {
+                // Validate
+                foreach (SceneObjectGroup gobj in m_attachments)
+                {
+                    if (gobj == null || gobj.IsDeleted)
+                        return false;
+                }
+
+                foreach (SceneObjectGroup gobj in m_attachments)
+                {
+                    // If the prim group is null then something must have happened to it!
+                    if (gobj != null && gobj.RootPart != null)
+                    {
+                        // Set the parent localID to 0 so it transfers over properly.
+                        gobj.RootPart.SetParentLocalId(0);
+                        gobj.AbsolutePosition = gobj.RootPart.AttachedPos;
+                        gobj.RootPart.IsAttachment = false;
+                        //gobj.RootPart.LastOwnerID = gobj.GetFromAssetID();
+                        m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Sending attachment {0} to region {1}", gobj.UUID, destination.RegionName);
+                        CrossPrimGroupIntoNewRegion(destination, gobj, silent);
+                    }
+                }
+                m_attachments.Clear();
+
+                return true;
+            }
+        }
+
+        #endregion
+
+        #region Misc
+
+        protected bool WaitForCallback(UUID id)
+        {
+            int count = 200;
+            while (m_agentsInTransit.Contains(id) && count-- > 0)
+            {
+                //m_log.Debug("  >>> Waiting... " + count);
+                Thread.Sleep(100);
+            }
+
+            if (count > 0)
+                return true;
+            else
+                return false;
+        }
+
+        protected void SetInTransit(UUID id)
+        {
+            lock (m_agentsInTransit)
+            {
+                if (!m_agentsInTransit.Contains(id))
+                    m_agentsInTransit.Add(id);
+            }
+        }
+
+        protected bool ResetFromTransit(UUID id)
+        {
+            lock (m_agentsInTransit)
+            {
+                if (m_agentsInTransit.Contains(id))
+                {
+                    m_agentsInTransit.Remove(id);
+                    return true;
+                }
+            }
+            return false;
+        }
+
+
+        #endregion
+
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs
new file mode 100644
index 0000000..28593fc
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs
@@ -0,0 +1,273 @@
+/*
+ * 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 OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Connectors.Hypergrid;
+using OpenSim.Services.Interfaces;
+using OpenSim.Server.Base;
+
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+
+namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
+{
+    public class HGEntityTransferModule : EntityTransferModule, ISharedRegionModule, IEntityTransferModule, IUserAgentVerificationModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private bool m_Initialized = false;
+
+        private GatekeeperServiceConnector m_GatekeeperConnector;
+
+        #region ISharedRegionModule
+
+        public override string Name
+        {
+            get { return "HGEntityTransferModule"; }
+        }
+
+        public override void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("EntityTransferModule", "");
+                if (name == Name)
+                {
+                    m_agentsInTransit = new List<UUID>();
+                    
+                    m_Enabled = true;
+                    m_log.InfoFormat("[HG ENTITY TRANSFER MODULE]: {0} enabled.", Name);
+                }
+            }
+        }
+
+        public override void AddRegion(Scene scene)
+        {
+            base.AddRegion(scene);
+            if (m_Enabled)
+            {
+                scene.RegisterModuleInterface<IUserAgentVerificationModule>(this);
+            }
+        }
+
+        protected override void OnNewClient(IClientAPI client)
+        {
+            client.OnTeleportHomeRequest += TeleportHome;
+            client.OnConnectionClosed += new Action<IClientAPI>(OnConnectionClosed);
+        }
+
+
+        public override void RegionLoaded(Scene scene)
+        {
+            base.RegionLoaded(scene);
+            if (m_Enabled)
+                if (!m_Initialized)
+                {
+                    m_GatekeeperConnector = new GatekeeperServiceConnector(scene.AssetService);
+                    m_Initialized = true;
+                }
+
+        }
+        public override void RemoveRegion(Scene scene)
+        {
+            base.AddRegion(scene);
+            if (m_Enabled)
+            {
+                scene.UnregisterModuleInterface<IUserAgentVerificationModule>(this);
+            }
+        }
+
+
+        #endregion
+
+        #region HG overrides of IEntiryTransferModule
+
+        protected override GridRegion GetFinalDestination(GridRegion region)
+        {
+            int flags = m_aScene.GridService.GetRegionFlags(m_aScene.RegionInfo.ScopeID, region.RegionID);
+            m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: region {0} flags: {1}", region.RegionID, flags);
+            if ((flags & (int)OpenSim.Data.RegionFlags.Hyperlink) != 0)
+            {
+                m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Destination region {0} is hyperlink", region.RegionID);
+                return m_GatekeeperConnector.GetHyperlinkRegion(region, region.RegionID);
+            }
+            return region;
+        }
+
+        protected override bool NeedsClosing(uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY, GridRegion reg)
+        {
+            if (base.NeedsClosing(oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
+                return true;
+
+            int flags = m_aScene.GridService.GetRegionFlags(m_aScene.RegionInfo.ScopeID, reg.RegionID);
+            if (flags == -1 /* no region in DB */ || (flags & (int)OpenSim.Data.RegionFlags.Hyperlink) != 0)
+                return true;
+
+            return false;
+        }
+
+        protected override bool CreateAgent(ScenePresence sp, GridRegion reg, GridRegion finalDestination, AgentCircuitData agentCircuit, uint teleportFlags, out string reason)
+        {
+            reason = string.Empty;
+            int flags = m_aScene.GridService.GetRegionFlags(m_aScene.RegionInfo.ScopeID, reg.RegionID);
+            if (flags == -1 /* no region in DB */ || (flags & (int)OpenSim.Data.RegionFlags.Hyperlink) != 0)
+            {
+                // this user is going to another grid
+                if (agentCircuit.ServiceURLs.ContainsKey("HomeURI"))
+                {
+                    string userAgentDriver = agentCircuit.ServiceURLs["HomeURI"].ToString();
+                    IUserAgentService connector = new UserAgentServiceConnector(userAgentDriver);
+                    bool success = connector.LoginAgentToGrid(agentCircuit, reg, finalDestination, out reason);
+                    if (success)
+                        // Log them out of this grid
+                        m_aScene.PresenceService.LogoutAgent(agentCircuit.SessionID, sp.AbsolutePosition, sp.Lookat);
+
+                    return success;
+                }
+                else
+                {
+                    m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Agent does not have a HomeURI address");
+                    return false;
+                }
+            }
+
+            return m_aScene.SimulationService.CreateAgent(reg, agentCircuit, teleportFlags, out reason);
+        }
+
+        public override void TeleportHome(UUID id, IClientAPI client)
+        {
+            m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Request to teleport {0} {1} home", client.FirstName, client.LastName);
+
+            // Let's find out if this is a foreign user or a local user
+            UserAccount account = m_aScene.UserAccountService.GetUserAccount(m_aScene.RegionInfo.ScopeID, id);
+            if (account != null)
+            {
+                // local grid user
+                m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: User is local");
+                base.TeleportHome(id, client);
+                return;
+            }
+
+            // Foreign user wants to go home
+            // 
+            AgentCircuitData aCircuit = ((Scene)(client.Scene)).AuthenticateHandler.GetAgentCircuitData(client.CircuitCode);
+            if (aCircuit == null || (aCircuit != null && !aCircuit.ServiceURLs.ContainsKey("HomeURI")))
+            {
+                client.SendTeleportFailed("Your information has been lost");
+                m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Unable to locate agent's gateway information");
+                return;
+            }
+
+            IUserAgentService userAgentService = new UserAgentServiceConnector(aCircuit.ServiceURLs["HomeURI"].ToString());
+            Vector3 position = Vector3.UnitY, lookAt = Vector3.UnitY;
+            GridRegion finalDestination = userAgentService.GetHomeRegion(aCircuit.AgentID, out position, out lookAt);
+            if (finalDestination == null)
+            {
+                client.SendTeleportFailed("Your home region could not be found");
+                m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Agent's home region not found");
+                return;
+            }
+
+            ScenePresence sp = ((Scene)(client.Scene)).GetScenePresence(client.AgentId);
+            if (sp == null)
+            {
+                client.SendTeleportFailed("Internal error");
+                m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Agent not found in the scene where it is supposed to be");
+                return;
+            }
+
+            IEventQueue eq = sp.Scene.RequestModuleInterface<IEventQueue>();
+            GridRegion homeGatekeeper = MakeRegion(aCircuit);
+            
+            m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: teleporting user {0} {1} home to {2} via {3}:{4}:{5}",
+                aCircuit.firstname, aCircuit.lastname, finalDestination.RegionName, homeGatekeeper.ExternalHostName, homeGatekeeper.HttpPort, homeGatekeeper.RegionName);
+
+            DoTeleport(sp, homeGatekeeper, finalDestination, position, lookAt, (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaHome), eq);
+        }
+        #endregion
+
+        #region IUserAgentVerificationModule
+
+        public bool VerifyClient(AgentCircuitData aCircuit, string token)
+        {
+            if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
+            {
+                string url = aCircuit.ServiceURLs["HomeURI"].ToString();
+                IUserAgentService security = new UserAgentServiceConnector(url);
+                return security.VerifyClient(aCircuit.SessionID, token);
+            }
+
+            return false;
+        }
+
+        void OnConnectionClosed(IClientAPI obj)
+        {
+            if (obj.IsLoggingOut)
+            {
+                AgentCircuitData aCircuit = ((Scene)(obj.Scene)).AuthenticateHandler.GetAgentCircuitData(obj.CircuitCode);
+
+                if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
+                {
+                    string url = aCircuit.ServiceURLs["HomeURI"].ToString();
+                    IUserAgentService security = new UserAgentServiceConnector(url);
+                    security.LogoutAgent(obj.AgentId, obj.SessionId);
+                    //m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Sent logout call to UserAgentService @ {0}", url);
+                }
+                else
+                    m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: HomeURI not found for agent {0} logout", obj.AgentId);
+            }
+        }
+
+        #endregion
+
+        private GridRegion MakeRegion(AgentCircuitData aCircuit)
+        {
+            GridRegion region = new GridRegion();
+
+            Uri uri = null;
+            if (!aCircuit.ServiceURLs.ContainsKey("HomeURI") || 
+                (aCircuit.ServiceURLs.ContainsKey("HomeURI") && !Uri.TryCreate(aCircuit.ServiceURLs["HomeURI"].ToString(), UriKind.Absolute, out uri)))
+                return null;
+
+            region.ExternalHostName = uri.Host;
+            region.HttpPort = (uint)uri.Port;
+            region.RegionName = string.Empty;
+            region.InternalEndPoint = new System.Net.IPEndPoint(System.Net.IPAddress.Parse("0.0.0.0"), (int)0);
+            return region;
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGAssetMapper.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGAssetMapper.cs
new file mode 100644
index 0000000..664f38d
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGAssetMapper.cs
@@ -0,0 +1,200 @@
+/*
+ * 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 OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using log4net;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Scenes.Serialization;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+
+//using HyperGrid.Framework;
+//using OpenSim.Region.Communications.Hypergrid;
+
+namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
+{
+    public class HGAssetMapper
+    {
+        #region Fields
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        // This maps between inventory server urls and inventory server clients
+//        private Dictionary<string, InventoryClient> m_inventoryServers = new Dictionary<string, InventoryClient>();
+
+        private Scene m_scene;
+
+        #endregion
+
+        #region Constructor
+
+        public HGAssetMapper(Scene scene)
+        {
+            m_scene = scene;
+        }
+
+        #endregion
+
+        #region Internal functions
+
+        public AssetBase FetchAsset(string url, UUID assetID)
+        {
+            AssetBase asset = m_scene.AssetService.Get(url + "/" + assetID.ToString());
+
+            if (asset != null)
+            {
+                m_log.DebugFormat("[HG ASSET MAPPER]: Copied asset {0} from {1} to local asset server. ", asset.ID, url);
+                return asset;
+            }
+            return null;
+        }
+
+        public bool PostAsset(string url, AssetBase asset)
+        {
+            if (asset != null)
+            {
+                // See long comment in AssetCache.AddAsset
+                if (!asset.Temporary || asset.Local)
+                {
+                    // We need to copy the asset into a new asset, because
+                    // we need to set its ID to be URL+UUID, so that the
+                    // HGAssetService dispatches it to the remote grid.
+                    // It's not pretty, but the best that can be done while
+                    // not having a global naming infrastructure
+                    AssetBase asset1 = new AssetBase(asset.FullID, asset.Name, asset.Type, asset.Metadata.CreatorID);
+                    Copy(asset, asset1);
+                    try
+                    {
+                        asset1.ID = url + "/" + asset.ID;
+                    }
+                    catch
+                    {
+                        m_log.Warn("[HG ASSET MAPPER]: Oops.");
+                    }
+
+                    m_scene.AssetService.Store(asset1);
+                    m_log.DebugFormat("[HG ASSET MAPPER]: Posted copy of asset {0} from local asset server to {1}", asset1.ID, url);
+                }
+                return true;
+           }
+            else
+                m_log.Warn("[HG ASSET MAPPER]: Tried to post asset to remote server, but asset not in local cache.");
+
+            return false;
+        }
+
+        private void Copy(AssetBase from, AssetBase to)
+        {
+            to.Data        = from.Data;
+            to.Description = from.Description;
+            to.FullID      = from.FullID;
+            to.ID          = from.ID;
+            to.Local       = from.Local;
+            to.Name        = from.Name;
+            to.Temporary   = from.Temporary;
+            to.Type        = from.Type;
+
+        }
+
+        // TODO: unused
+        // private void Dump(Dictionary<UUID, bool> lst)
+        // {
+        //     m_log.Debug("XXX -------- UUID DUMP ------- XXX");
+        //     foreach (KeyValuePair<UUID, bool> kvp in lst)
+        //         m_log.Debug(" >> " + kvp.Key + " (texture? " + kvp.Value + ")");
+        //     m_log.Debug("XXX -------- UUID DUMP ------- XXX");
+        // }
+
+        #endregion
+
+
+        #region Public interface
+
+        public void Get(UUID assetID, UUID ownerID, string userAssetURL)
+        {
+            // Get the item from the remote asset server onto the local AssetCache
+            // and place an entry in m_assetMap
+
+            m_log.Debug("[HG ASSET MAPPER]: Fetching object " + assetID + " from asset server " + userAssetURL);
+            AssetBase asset = FetchAsset(userAssetURL, assetID); 
+
+            if (asset != null)
+            {
+                // OK, now fetch the inside.
+                Dictionary<UUID, int> ids = new Dictionary<UUID, int>();
+                HGUuidGatherer uuidGatherer = new HGUuidGatherer(this, m_scene.AssetService, userAssetURL);
+                uuidGatherer.GatherAssetUuids(asset.FullID, (AssetType)asset.Type, ids);
+                foreach (UUID uuid in ids.Keys)
+                    FetchAsset(userAssetURL, uuid);
+
+                m_log.DebugFormat("[HG ASSET MAPPER]: Successfully fetched asset {0} from asset server {1}", asset.ID, userAssetURL);
+
+            }
+            else
+                m_log.Warn("[HG ASSET MAPPER]: Could not fetch asset from remote asset server " + userAssetURL);
+        }
+
+
+        public void Post(UUID assetID, UUID ownerID, string userAssetURL)
+        {
+                // Post the item from the local AssetCache onto the remote asset server
+                // and place an entry in m_assetMap
+
+            m_log.Debug("[HG ASSET MAPPER]: Posting object " + assetID + " to asset server " + userAssetURL);
+            AssetBase asset = m_scene.AssetService.Get(assetID.ToString());
+            if (asset != null)
+            {
+                Dictionary<UUID, int> ids = new Dictionary<UUID, int>();
+                HGUuidGatherer uuidGatherer = new HGUuidGatherer(this, m_scene.AssetService, string.Empty);
+                uuidGatherer.GatherAssetUuids(asset.FullID, (AssetType)asset.Type, ids);
+                foreach (UUID uuid in ids.Keys)
+                {
+                    asset = m_scene.AssetService.Get(uuid.ToString());
+                    if (asset == null)
+                        m_log.DebugFormat("[HG ASSET MAPPER]: Could not find asset {0}", uuid);
+                    else
+                        PostAsset(userAssetURL, asset);
+                }
+
+                 // maybe all pieces got there...
+                m_log.DebugFormat("[HG ASSET MAPPER]: Successfully posted item {0} to asset server {1}", assetID, userAssetURL);
+
+            }
+            else
+                m_log.DebugFormat("[HG ASSET MAPPER]: Something wrong with asset {0}, it could not be found", assetID);
+
+        }
+
+        #endregion
+
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGInventoryAccessModule.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGInventoryAccessModule.cs
new file mode 100644
index 0000000..25f5154
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGInventoryAccessModule.cs
@@ -0,0 +1,207 @@
+/*
+ * 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 OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Connectors.Hypergrid;
+using OpenSim.Services.Interfaces;
+using OpenSim.Server.Base;
+
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+
+namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
+{
+    public class HGInventoryAccessModule : BasicInventoryAccessModule, INonSharedRegionModule, IInventoryAccessModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static HGAssetMapper m_assMapper;
+        public static HGAssetMapper AssetMapper
+        {
+            get { return m_assMapper; }
+        }
+
+        private bool m_Initialized = false;
+
+        #region INonSharedRegionModule
+
+        public override string Name
+        {
+            get { return "HGInventoryAccessModule"; }
+        }
+
+        public override void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("InventoryAccessModule", "");
+                if (name == Name)
+                {
+                    m_Enabled = true;
+                    m_log.InfoFormat("[HG INVENTORY ACCESS MODULE]: {0} enabled.", Name);
+                }
+            }
+        }
+
+        public override void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            base.AddRegion(scene);
+            m_assMapper = new HGAssetMapper(scene);
+            scene.EventManager.OnNewInventoryItemUploadComplete += UploadInventoryItem;
+
+        }
+
+        #endregion
+
+        #region Event handlers
+
+        public void UploadInventoryItem(UUID avatarID, UUID assetID, string name, int userlevel)
+        {
+            string userAssetServer = string.Empty;
+            if (IsForeignUser(avatarID, out userAssetServer))
+            {
+                m_assMapper.Post(assetID, avatarID, userAssetServer);
+            }
+        }
+
+        #endregion
+
+        #region Overrides of Basic Inventory Access methods
+        /// 
+        /// CapsUpdateInventoryItemAsset
+        ///
+        public override UUID CapsUpdateInventoryItemAsset(IClientAPI remoteClient, UUID itemID, byte[] data)
+        {
+            UUID newAssetID = base.CapsUpdateInventoryItemAsset(remoteClient, itemID, data);
+
+            UploadInventoryItem(remoteClient.AgentId, newAssetID, "", 0);
+
+            return newAssetID;
+        }
+
+        ///
+        /// DeleteToInventory
+        ///
+        public override UUID DeleteToInventory(DeRezAction action, UUID folderID, SceneObjectGroup objectGroup, IClientAPI remoteClient)
+        {
+            UUID assetID = base.DeleteToInventory(action, folderID, objectGroup, remoteClient);
+
+            if (!assetID.Equals(UUID.Zero))
+            {
+                UploadInventoryItem(remoteClient.AgentId, assetID, "", 0);
+            }
+            else
+                m_log.Debug("[HGScene]: Scene.Inventory did not create asset");
+
+            return assetID;
+        }
+
+        ///
+        /// RezObject
+        ///
+        public override SceneObjectGroup RezObject(IClientAPI remoteClient, UUID itemID, Vector3 RayEnd, Vector3 RayStart,
+                                                   UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
+                                                   bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment)
+        {
+            m_log.DebugFormat("[HGScene] RezObject itemID={0} fromTaskID={1}", itemID, fromTaskID);
+
+            //if (fromTaskID.Equals(UUID.Zero))
+            //{
+            InventoryItemBase item = new InventoryItemBase(itemID);
+            item.Owner = remoteClient.AgentId;
+            item = m_Scene.InventoryService.GetItem(item);
+            //if (item == null)
+            //{ // Fetch the item
+            //    item = new InventoryItemBase();
+            //    item.Owner = remoteClient.AgentId;
+            //    item.ID = itemID;
+            //    item = m_assMapper.Get(item, userInfo.RootFolder.ID, userInfo);
+            //}
+            string userAssetServer = string.Empty;
+            if (item != null && IsForeignUser(remoteClient.AgentId, out userAssetServer))
+            {
+                m_assMapper.Get(item.AssetID, remoteClient.AgentId, userAssetServer);
+
+            }
+            //}
+
+            // OK, we're done fetching. Pass it up to the default RezObject
+            return base.RezObject(remoteClient, itemID, RayEnd, RayStart, RayTargetID, BypassRayCast, RayEndIsIntersection,
+                                  RezSelected, RemoveItem, fromTaskID, attachment);
+
+        }
+
+        public override void TransferInventoryAssets(InventoryItemBase item, UUID sender, UUID receiver)
+        {
+            string userAssetServer = string.Empty;
+            if (IsForeignUser(sender, out userAssetServer))
+                m_assMapper.Get(item.AssetID, sender, userAssetServer);
+
+            if (IsForeignUser(receiver, out userAssetServer))
+                m_assMapper.Post(item.AssetID, receiver, userAssetServer);
+        }
+
+        #endregion
+
+        public bool IsForeignUser(UUID userID, out string assetServerURL)
+        {
+            assetServerURL = string.Empty;
+            UserAccount account = null;
+            if (m_Scene.UserAccountService != null)
+                account = m_Scene.UserAccountService.GetUserAccount(m_Scene.RegionInfo.ScopeID, userID);
+
+            if (account == null) // foreign
+            {
+                ScenePresence sp = null;
+                if (m_Scene.TryGetAvatar(userID, out sp))
+                {
+                    AgentCircuitData aCircuit = m_Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
+                    if (aCircuit.ServiceURLs.ContainsKey("AssetServerURI"))
+                    {
+                        assetServerURL = aCircuit.ServiceURLs["AssetServerURI"].ToString();
+                        assetServerURL = assetServerURL.Trim(new char[] { '/' }); return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGUuidGatherer.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGUuidGatherer.cs
new file mode 100644
index 0000000..fcb544f
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGUuidGatherer.cs
@@ -0,0 +1,57 @@
+/*
+ * 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 OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+
+namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
+{
+    public class HGUuidGatherer : UuidGatherer
+    {
+        protected string m_assetServerURL;
+        protected HGAssetMapper m_assetMapper;
+
+        public HGUuidGatherer(HGAssetMapper assMap, IAssetService assetCache, string assetServerURL) : base(assetCache)
+        {
+            m_assetMapper = assMap;
+            m_assetServerURL = assetServerURL;
+        }
+
+        protected override AssetBase GetAsset(UUID uuid)
+        {
+            if (string.Empty == m_assetServerURL)
+                return m_assetCache.Get(uuid.ToString());
+            else
+                return m_assetMapper.FetchAsset(m_assetServerURL, uuid);
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
new file mode 100644
index 0000000..e0df288
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
@@ -0,0 +1,655 @@
+/*
+ * 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 OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+using System.Threading;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Client;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Scenes.Serialization;
+using OpenSim.Services.Interfaces;
+
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+
+namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
+{
+    public class BasicInventoryAccessModule : INonSharedRegionModule, IInventoryAccessModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected bool m_Enabled = false;
+        protected Scene m_Scene;
+
+        #region INonSharedRegionModule
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public virtual string Name
+        {
+            get { return "BasicInventoryAccessModule"; }
+        }
+
+        public virtual void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("InventoryAccessModule", "");
+                if (name == Name)
+                {
+                    m_Enabled = true;
+                    m_log.InfoFormat("[INVENTORY ACCESS MODULE]: {0} enabled.", Name);
+                }
+            }
+        }
+
+        public virtual void PostInitialise()
+        {
+        }
+
+        public virtual void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_Scene = scene;
+
+            scene.RegisterModuleInterface<IInventoryAccessModule>(this);
+            scene.EventManager.OnNewClient += OnNewClient;
+        }
+
+        protected virtual void OnNewClient(IClientAPI client)
+        {
+            
+        }
+
+        public virtual void Close()
+        {
+            if (!m_Enabled)
+                return;
+        }
+
+
+        public virtual void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+            m_Scene = null;
+        }
+
+        public virtual void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+        }
+
+        #endregion
+
+        #region Inventory Access
+
+        /// <summary>
+        /// Capability originating call to update the asset of an item in an agent's inventory
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="itemID"></param>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public virtual UUID CapsUpdateInventoryItemAsset(IClientAPI remoteClient, UUID itemID, byte[] data)
+        {
+            InventoryItemBase item = new InventoryItemBase(itemID, remoteClient.AgentId);
+            item = m_Scene.InventoryService.GetItem(item);
+
+            if (item != null)
+            {
+                if ((InventoryType)item.InvType == InventoryType.Notecard)
+                {
+                    if (!m_Scene.Permissions.CanEditNotecard(itemID, UUID.Zero, remoteClient.AgentId))
+                    {
+                        remoteClient.SendAgentAlertMessage("Insufficient permissions to edit notecard", false);
+                        return UUID.Zero;
+                    }
+
+                    remoteClient.SendAgentAlertMessage("Notecard saved", false);
+                }
+                else if ((InventoryType)item.InvType == InventoryType.LSL)
+                {
+                    if (!m_Scene.Permissions.CanEditScript(itemID, UUID.Zero, remoteClient.AgentId))
+                    {
+                        remoteClient.SendAgentAlertMessage("Insufficient permissions to edit script", false);
+                        return UUID.Zero;
+                    }
+
+                    remoteClient.SendAgentAlertMessage("Script saved", false);
+                }
+
+                AssetBase asset =
+                    CreateAsset(item.Name, item.Description, (sbyte)item.AssetType, data, remoteClient.AgentId.ToString());
+                item.AssetID = asset.FullID;
+                m_Scene.AssetService.Store(asset);
+
+                m_Scene.InventoryService.UpdateItem(item);
+
+                // remoteClient.SendInventoryItemCreateUpdate(item);
+                return (asset.FullID);
+            }
+            else
+            {
+                m_log.ErrorFormat(
+                    "[AGENT INVENTORY]: Could not find item {0} for caps inventory update",
+                    itemID);
+            }
+
+            return UUID.Zero;
+        }
+
+        /// <summary>
+        /// Delete a scene object from a scene and place in the given avatar's inventory.
+        /// Returns the UUID of the newly created asset.
+        /// </summary>
+        /// <param name="action"></param>
+        /// <param name="folderID"></param>
+        /// <param name="objectGroup"></param>
+        /// <param name="remoteClient"> </param>
+        public virtual UUID DeleteToInventory(DeRezAction action, UUID folderID,
+                SceneObjectGroup objectGroup, IClientAPI remoteClient)
+        {
+            UUID assetID = UUID.Zero;
+
+            Vector3 inventoryStoredPosition = new Vector3
+                        (((objectGroup.AbsolutePosition.X > (int)Constants.RegionSize)
+                              ? 250
+                              : objectGroup.AbsolutePosition.X)
+                         ,
+                         (objectGroup.AbsolutePosition.X > (int)Constants.RegionSize)
+                             ? 250
+                             : objectGroup.AbsolutePosition.X,
+                         objectGroup.AbsolutePosition.Z);
+
+            Vector3 originalPosition = objectGroup.AbsolutePosition;
+
+            objectGroup.AbsolutePosition = inventoryStoredPosition;
+
+            string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(objectGroup);
+
+            objectGroup.AbsolutePosition = originalPosition;
+
+            // Get the user info of the item destination
+            //
+            UUID userID = UUID.Zero;
+
+            if (action == DeRezAction.Take || action == DeRezAction.TakeCopy ||
+                action == DeRezAction.SaveToExistingUserInventoryItem)
+            {
+                // Take or take copy require a taker
+                // Saving changes requires a local user
+                //
+                if (remoteClient == null)
+                    return UUID.Zero;
+
+                userID = remoteClient.AgentId;
+            }
+            else
+            {
+                // All returns / deletes go to the object owner
+                //
+
+                userID = objectGroup.RootPart.OwnerID;
+            }
+
+            if (userID == UUID.Zero) // Can't proceed
+            {
+                return UUID.Zero;
+            }
+
+            // If we're returning someone's item, it goes back to the
+            // owner's Lost And Found folder.
+            // Delete is treated like return in this case
+            // Deleting your own items makes them go to trash
+            //
+
+            InventoryFolderBase folder = null;
+            InventoryItemBase item = null;
+
+            if (DeRezAction.SaveToExistingUserInventoryItem == action)
+            {
+                item = new InventoryItemBase(objectGroup.RootPart.FromUserInventoryItemID, userID);
+                item = m_Scene.InventoryService.GetItem(item);
+
+                //item = userInfo.RootFolder.FindItem(
+                //        objectGroup.RootPart.FromUserInventoryItemID);
+
+                if (null == item)
+                {
+                    m_log.DebugFormat(
+                        "[AGENT INVENTORY]: Object {0} {1} scheduled for save to inventory has already been deleted.",
+                        objectGroup.Name, objectGroup.UUID);
+                    return UUID.Zero;
+                }
+            }
+            else
+            {
+                // Folder magic
+                //
+                if (action == DeRezAction.Delete)
+                {
+                    // Deleting someone else's item
+                    //
+
+
+                    if (remoteClient == null ||
+                        objectGroup.OwnerID != remoteClient.AgentId)
+                    {
+                        // Folder skeleton may not be loaded and we
+                        // have to wait for the inventory to find
+                        // the destination folder
+                        //
+                        folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
+                    }
+                    else
+                    {
+                        // Assume inventory skeleton was loaded during login
+                        // and all folders can be found
+                        //
+                        folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
+                    }
+                }
+                else if (action == DeRezAction.Return)
+                {
+
+                    // Dump to lost + found unconditionally
+                    //
+                    folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
+                }
+
+                if (folderID == UUID.Zero && folder == null)
+                {
+                    if (action == DeRezAction.Delete)
+                    {
+                        // Deletes go to trash by default
+                        //
+                        folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder);
+                    }
+                    else
+                    {
+                        // Catch all. Use lost & found
+                        //
+
+                        folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder);
+                    }
+                }
+
+                if (folder == null) // None of the above
+                {
+                    //folder = userInfo.RootFolder.FindFolder(folderID);
+                    folder = new InventoryFolderBase(folderID);
+
+                    if (folder == null) // Nowhere to put it
+                    {
+                        return UUID.Zero;
+                    }
+                }
+
+                item = new InventoryItemBase();
+                item.CreatorId = objectGroup.RootPart.CreatorID.ToString();
+                item.ID = UUID.Random();
+                item.InvType = (int)InventoryType.Object;
+                item.Folder = folder.ID;
+                item.Owner = userID;
+            }
+
+            AssetBase asset = CreateAsset(
+                objectGroup.GetPartName(objectGroup.RootPart.LocalId),
+                objectGroup.GetPartDescription(objectGroup.RootPart.LocalId),
+                (sbyte)AssetType.Object,
+                Utils.StringToBytes(sceneObjectXml),
+                objectGroup.OwnerID.ToString());
+            m_Scene.AssetService.Store(asset);
+            assetID = asset.FullID;
+
+            if (DeRezAction.SaveToExistingUserInventoryItem == action)
+            {
+                item.AssetID = asset.FullID;
+                m_Scene.InventoryService.UpdateItem(item);
+            }
+            else
+            {
+                item.AssetID = asset.FullID;
+
+                if (remoteClient != null && (remoteClient.AgentId != objectGroup.RootPart.OwnerID) && m_Scene.Permissions.PropagatePermissions())
+                {
+                    uint perms = objectGroup.GetEffectivePermissions();
+                    uint nextPerms = (perms & 7) << 13;
+                    if ((nextPerms & (uint)PermissionMask.Copy) == 0)
+                        perms &= ~(uint)PermissionMask.Copy;
+                    if ((nextPerms & (uint)PermissionMask.Transfer) == 0)
+                        perms &= ~(uint)PermissionMask.Transfer;
+                    if ((nextPerms & (uint)PermissionMask.Modify) == 0)
+                        perms &= ~(uint)PermissionMask.Modify;
+
+                    item.BasePermissions = perms & objectGroup.RootPart.NextOwnerMask;
+                    item.CurrentPermissions = item.BasePermissions;
+                    item.NextPermissions = objectGroup.RootPart.NextOwnerMask;
+                    item.EveryOnePermissions = objectGroup.RootPart.EveryoneMask & objectGroup.RootPart.NextOwnerMask;
+                    item.GroupPermissions = objectGroup.RootPart.GroupMask & objectGroup.RootPart.NextOwnerMask;
+                    item.CurrentPermissions |= 8; // Slam!
+                }
+                else
+                {
+                    item.BasePermissions = objectGroup.GetEffectivePermissions();
+                    item.CurrentPermissions = objectGroup.GetEffectivePermissions();
+                    item.NextPermissions = objectGroup.RootPart.NextOwnerMask;
+                    item.EveryOnePermissions = objectGroup.RootPart.EveryoneMask;
+                    item.GroupPermissions = objectGroup.RootPart.GroupMask;
+
+                    item.CurrentPermissions |= 8; // Slam!
+                }
+
+                // TODO: add the new fields (Flags, Sale info, etc)
+                item.CreationDate = Util.UnixTimeSinceEpoch();
+                item.Description = asset.Description;
+                item.Name = asset.Name;
+                item.AssetType = asset.Type;
+
+                m_Scene.InventoryService.AddItem(item);
+
+                if (remoteClient != null && item.Owner == remoteClient.AgentId)
+                {
+                    remoteClient.SendInventoryItemCreateUpdate(item, 0);
+                }
+                else
+                {
+                    ScenePresence notifyUser = m_Scene.GetScenePresence(item.Owner);
+                    if (notifyUser != null)
+                    {
+                        notifyUser.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
+                    }
+                }
+            }
+
+            return assetID;
+        }
+
+
+        /// <summary>
+        /// Rez an object into the scene from the user's inventory
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="itemID"></param>
+        /// <param name="RayEnd"></param>
+        /// <param name="RayStart"></param>
+        /// <param name="RayTargetID"></param>
+        /// <param name="BypassRayCast"></param>
+        /// <param name="RayEndIsIntersection"></param>
+        /// <param name="RezSelected"></param>
+        /// <param name="RemoveItem"></param>
+        /// <param name="fromTaskID"></param>
+        /// <param name="attachment"></param>
+        /// <returns>The SceneObjectGroup rezzed or null if rez was unsuccessful.</returns>
+        public virtual SceneObjectGroup RezObject(IClientAPI remoteClient, UUID itemID, Vector3 RayEnd, Vector3 RayStart,
+                                    UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
+                                    bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment)
+        {
+            // Work out position details
+            byte bRayEndIsIntersection = (byte)0;
+
+            if (RayEndIsIntersection)
+            {
+                bRayEndIsIntersection = (byte)1;
+            }
+            else
+            {
+                bRayEndIsIntersection = (byte)0;
+            }
+
+            Vector3 scale = new Vector3(0.5f, 0.5f, 0.5f);
+
+
+            Vector3 pos = m_Scene.GetNewRezLocation(
+                      RayStart, RayEnd, RayTargetID, Quaternion.Identity,
+                      BypassRayCast, bRayEndIsIntersection, true, scale, false);
+
+            // Rez object
+            InventoryItemBase item = new InventoryItemBase(itemID, remoteClient.AgentId);
+            item = m_Scene.InventoryService.GetItem(item);
+
+            if (item != null)
+            {
+                AssetBase rezAsset = m_Scene.AssetService.Get(item.AssetID.ToString());
+
+                if (rezAsset != null)
+                {
+                    UUID itemId = UUID.Zero;
+
+                    // If we have permission to copy then link the rezzed object back to the user inventory
+                    // item that it came from.  This allows us to enable 'save object to inventory'
+                    if (!m_Scene.Permissions.BypassPermissions())
+                    {
+                        if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == (uint)PermissionMask.Copy)
+                        {
+                            itemId = item.ID;
+                        }
+                    }
+                    else
+                    {
+                        // Brave new fullperm world
+                        //
+                        itemId = item.ID;
+                    }
+
+                    string xmlData = Utils.BytesToString(rezAsset.Data);
+                    SceneObjectGroup group
+                        = SceneObjectSerializer.FromOriginalXmlFormat(itemId, xmlData);
+
+                    if (!m_Scene.Permissions.CanRezObject(
+                        group.Children.Count, remoteClient.AgentId, pos)
+                        && !attachment)
+                    {
+                        // The client operates in no fail mode. It will
+                        // have already removed the item from the folder
+                        // if it's no copy.
+                        // Put it back if it's not an attachment
+                        //
+                        if (((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0) && (!attachment))
+                            remoteClient.SendBulkUpdateInventory(item);
+                        return null;
+                    }
+
+                    group.ResetIDs();
+
+                    if (attachment)
+                    {
+                        group.RootPart.ObjectFlags |= (uint)PrimFlags.Phantom;
+                        group.RootPart.IsAttachment = true;
+                    }
+
+                    m_Scene.AddNewSceneObject(group, true);
+
+                    //  m_log.InfoFormat("ray end point for inventory rezz is {0} {1} {2} ", RayEnd.X, RayEnd.Y, RayEnd.Z);
+                    // if attachment we set it's asset id so object updates can reflect that
+                    // if not, we set it's position in world.
+                    if (!attachment)
+                    {
+                        float offsetHeight = 0;
+                        pos = m_Scene.GetNewRezLocation(
+                            RayStart, RayEnd, RayTargetID, Quaternion.Identity,
+                            BypassRayCast, bRayEndIsIntersection, true, group.GetAxisAlignedBoundingBox(out offsetHeight), false);
+                        pos.Z += offsetHeight;
+                        group.AbsolutePosition = pos;
+                        //   m_log.InfoFormat("rezx point for inventory rezz is {0} {1} {2}  and offsetheight was {3}", pos.X, pos.Y, pos.Z, offsetHeight);
+
+                    }
+                    else
+                    {
+                        group.SetFromItemID(itemID);
+                    }
+
+                    SceneObjectPart rootPart = null;
+                    try
+                    {
+                        rootPart = group.GetChildPart(group.UUID);
+                    }
+                    catch (NullReferenceException)
+                    {
+                        string isAttachment = "";
+
+                        if (attachment)
+                            isAttachment = " Object was an attachment";
+
+                        m_log.Error("[AGENT INVENTORY]: Error rezzing ItemID: " + itemID + " object has no rootpart." + isAttachment);
+                    }
+
+                    // Since renaming the item in the inventory does not affect the name stored
+                    // in the serialization, transfer the correct name from the inventory to the
+                    // object itself before we rez.
+                    rootPart.Name = item.Name;
+                    rootPart.Description = item.Description;
+
+                    List<SceneObjectPart> partList = new List<SceneObjectPart>(group.Children.Values);
+
+                    group.SetGroup(remoteClient.ActiveGroupId, remoteClient);
+                    if (rootPart.OwnerID != item.Owner)
+                    {
+                        //Need to kill the for sale here
+                        rootPart.ObjectSaleType = 0;
+                        rootPart.SalePrice = 10;
+
+                        if (m_Scene.Permissions.PropagatePermissions())
+                        {
+                            if ((item.CurrentPermissions & 8) != 0)
+                            {
+                                foreach (SceneObjectPart part in partList)
+                                {
+                                    part.EveryoneMask = item.EveryOnePermissions;
+                                    part.NextOwnerMask = item.NextPermissions;
+                                    part.GroupMask = 0; // DO NOT propagate here
+                                }
+                            }
+                            group.ApplyNextOwnerPermissions();
+                        }
+                    }
+
+                    foreach (SceneObjectPart part in partList)
+                    {
+                        if (part.OwnerID != item.Owner)
+                        {
+                            part.LastOwnerID = part.OwnerID;
+                            part.OwnerID = item.Owner;
+                            part.Inventory.ChangeInventoryOwner(item.Owner);
+                        }
+                        else if (((item.CurrentPermissions & 8) != 0) && (!attachment)) // Slam!
+                        {
+                            part.EveryoneMask = item.EveryOnePermissions;
+                            part.NextOwnerMask = item.NextPermissions;
+
+                            part.GroupMask = 0; // DO NOT propagate here
+                        }
+                    }
+
+                    rootPart.TrimPermissions();
+
+                    if (!attachment)
+                    {
+                        if (group.RootPart.Shape.PCode == (byte)PCode.Prim)
+                        {
+                            group.ClearPartAttachmentData();
+                        }
+                    }
+
+                    if (!attachment)
+                    {
+                        // Fire on_rez
+                        group.CreateScriptInstances(0, true, m_Scene.DefaultScriptEngine, 0);
+
+                        rootPart.ScheduleFullUpdate();
+                    }
+
+                    if (!m_Scene.Permissions.BypassPermissions())
+                    {
+                        if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
+                        {
+                            // If this is done on attachments, no
+                            // copy ones will be lost, so avoid it
+                            //
+                            if (!attachment)
+                            {
+                                List<UUID> uuids = new List<UUID>();
+                                uuids.Add(item.ID);
+                                m_Scene.InventoryService.DeleteItems(item.Owner, uuids);
+                            }
+                        }
+                    }
+
+                    return rootPart.ParentGroup;
+                }
+            }
+
+            return null;
+        }
+
+        public virtual void TransferInventoryAssets(InventoryItemBase item, UUID sender, UUID receiver)
+        {
+        }
+
+        #endregion
+
+        #region Misc
+
+        /// <summary>
+        /// Create a new asset data structure.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="description"></param>
+        /// <param name="invType"></param>
+        /// <param name="assetType"></param>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        private AssetBase CreateAsset(string name, string description, sbyte assetType, byte[] data, string creatorID)
+        {
+            AssetBase asset = new AssetBase(UUID.Random(), name, assetType, creatorID);
+            asset.Description = description;
+            asset.Data = (data == null) ? new byte[1] : data;
+
+            return asset;
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Framework/Library/LibraryModule.cs b/OpenSim/Region/CoreModules/Framework/Library/LibraryModule.cs
index 13f58bd..e37da9f 100644
--- a/OpenSim/Region/CoreModules/Framework/Library/LibraryModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/Library/LibraryModule.cs
@@ -31,12 +31,13 @@ using System.Reflection;
 
 using OpenSim.Framework;
 using OpenSim.Framework.Communications;
-using OpenSim.Framework.Communications.Cache;
+
 using OpenSim.Region.CoreModules.Avatar.Inventory.Archiver;
 using OpenSim.Region.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
+using OpenSim.Server.Base;
 
 using OpenMetaverse;
 using log4net;
@@ -53,6 +54,8 @@ namespace OpenSim.Region.CoreModules.Framework.Library
         private string m_LibraryName = "OpenSim Library";
         private Scene m_Scene;
 
+        private ILibraryService m_Library;
+
         #region ISharedRegionModule
 
         public void Initialise(IConfigSource config)
@@ -60,9 +63,22 @@ namespace OpenSim.Region.CoreModules.Framework.Library
             m_Enabled = config.Configs["Modules"].GetBoolean("LibraryModule", m_Enabled);
             if (m_Enabled)
             {
-                IConfig libConfig = config.Configs["LibraryModule"];
+                IConfig libConfig = config.Configs["LibraryService"];
                 if (libConfig != null)
-                    m_LibraryName = libConfig.GetString("LibraryName", m_LibraryName);
+                {
+                    string dllName = libConfig.GetString("LocalServiceModule", string.Empty);
+                    m_log.Debug("[LIBRARY MODULE]: Library service dll is " + dllName);
+                    if (dllName != string.Empty)
+                    {
+                        Object[] args = new Object[] { config };
+                        m_Library = ServerUtils.LoadPlugin<ILibraryService>(dllName, args);
+                    }
+                }
+            }
+            if (m_Library == null)
+            {
+                m_log.Warn("[LIBRARY MODULE]: No local library service. Module will be disabled.");
+                m_Enabled = false;
             }
         }
 
@@ -91,10 +107,15 @@ namespace OpenSim.Region.CoreModules.Framework.Library
             {
                 m_Scene = scene;
             }
+            scene.RegisterModuleInterface<ILibraryService>(m_Library);
         }
 
         public void RemoveRegion(Scene scene)
         {
+            if (!m_Enabled)
+                return;
+
+            scene.UnregisterModuleInterface<ILibraryService>(m_Library);
         }
 
         public void RegionLoaded(Scene scene)
@@ -127,27 +148,23 @@ namespace OpenSim.Region.CoreModules.Framework.Library
 
         protected void LoadLibrariesFromArchives()
         {
-            InventoryFolderImpl lib = m_Scene.CommsManager.UserProfileCacheService.LibraryRoot;
+            InventoryFolderImpl lib = m_Library.LibraryRootFolder;
             if (lib == null)
             {
                 m_log.Debug("[LIBRARY MODULE]: No library. Ignoring Library Module");
                 return;
             }
 
-            lib.Name = m_LibraryName;
-
             RegionInfo regInfo = new RegionInfo();
             Scene m_MockScene = new Scene(regInfo);
-            m_MockScene.CommsManager = m_Scene.CommsManager;
-            LocalInventoryService invService = new LocalInventoryService((LibraryRootFolder)lib);
+            LocalInventoryService invService = new LocalInventoryService(lib);
             m_MockScene.RegisterModuleInterface<IInventoryService>(invService);
             m_MockScene.RegisterModuleInterface<IAssetService>(m_Scene.AssetService);
 
-            UserProfileData profile = new UserProfileData();
-            profile.FirstName = "OpenSim";
-            profile.ID = lib.Owner;
-            profile.SurName = "Library";
-            CachedUserInfo uinfo = new CachedUserInfo(invService, profile);
+            UserAccount uinfo = new UserAccount(lib.Owner);
+            uinfo.FirstName = "OpenSim";
+            uinfo.LastName = "Library";
+            uinfo.ServiceURLs = new Dictionary<string, object>();
 
             foreach (string iarFileName in Directory.GetFiles(pathToLibraries, "*.iar"))
             {
@@ -175,6 +192,15 @@ namespace OpenSim.Region.CoreModules.Framework.Library
                     m_log.DebugFormat("[LIBRARY MODULE]: Exception when processing archive {0}: {1}", iarFileName, e.Message);
                 }
             }
+
+        }
+
+        private void DumpLibrary()
+        {
+            InventoryFolderImpl lib = m_Library.LibraryRootFolder;
+
+            m_log.DebugFormat(" - folder {0}", lib.Name);
+            DumpFolder(lib);
         }
 //
 //        private void DumpLibrary()
diff --git a/OpenSim/Region/CoreModules/Framework/Library/LocalInventoryService.cs b/OpenSim/Region/CoreModules/Framework/Library/LocalInventoryService.cs
index 2c95b5a..49589fd 100644
--- a/OpenSim/Region/CoreModules/Framework/Library/LocalInventoryService.cs
+++ b/OpenSim/Region/CoreModules/Framework/Library/LocalInventoryService.cs
@@ -29,7 +29,7 @@ using System.Collections.Generic;
 using System.Reflection;
 
 using OpenSim.Framework;
-using OpenSim.Framework.Communications.Cache;
+
 using OpenSim.Services.Interfaces;
 
 using OpenMetaverse;
@@ -41,9 +41,9 @@ namespace OpenSim.Region.CoreModules.Framework.Library
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        private LibraryRootFolder m_Library;
+        private InventoryFolderImpl m_Library;
 
-        public LocalInventoryService(LibraryRootFolder lib)
+        public LocalInventoryService(InventoryFolderImpl lib)
         {
             m_Library = lib;
         }