Initial update to OpenSim 0.8.2.1 source code.

3 files changed, 1731 insertions, 765 deletions

diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
index c43edd2..a2417c4 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
@@ -33,9 +33,10 @@ using System.Threading;
 using OpenSim.Framework;
 using OpenSim.Framework.Capabilities;
 using OpenSim.Framework.Client;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
-using OpenSim.Region.Physics.Manager;
+using OpenSim.Region.PhysicsModules.SharedBase;
 using OpenSim.Services.Interfaces;
 
 using GridRegion = OpenSim.Services.Interfaces.GridRegion;
@@ -51,15 +52,61 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
     public class EntityTransferModule : INonSharedRegionModule, IEntityTransferModule
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[ENTITY TRANSFER MODULE]";
 
+        public const int DefaultMaxTransferDistance = 4095;
         public const bool WaitForAgentArrivedAtDestinationDefault = true;
 
         /// <summary>
+        /// The maximum distance, in standard region units (256m) that an agent is allowed to transfer.
+        /// </summary>
+        public int MaxTransferDistance { get; set; }
+
+        /// <summary>
         /// If true then on a teleport, the source region waits for a callback from the destination region.  If
         /// a callback fails to arrive within a set time then the user is pulled back into the source region.
         /// </summary>
         public bool WaitForAgentArrivedAtDestination { get; set; }
 
+        /// <summary>
+        /// If true then we ask the viewer to disable teleport cancellation and ignore teleport requests.
+        /// </summary>
+        /// <remarks>
+        /// This is useful in situations where teleport is very likely to always succeed and we want to avoid a 
+        /// situation where avatars can be come 'stuck' due to a failed teleport cancellation.  Unfortunately, the
+        /// nature of the teleport protocol makes it extremely difficult (maybe impossible) to make teleport 
+        /// cancellation consistently suceed.
+        /// </remarks>
+        public bool DisableInterRegionTeleportCancellation { get; set; }
+
+        /// <summary>
+        /// Number of times inter-region teleport was attempted.
+        /// </summary>
+        private Stat m_interRegionTeleportAttempts;
+
+        /// <summary>
+        /// Number of times inter-region teleport was aborted (due to simultaneous client logout).
+        /// </summary>
+        private Stat m_interRegionTeleportAborts;
+
+        /// <summary>
+        /// Number of times inter-region teleport was successfully cancelled by the client.
+        /// </summary>
+        private Stat m_interRegionTeleportCancels;
+
+        /// <summary>
+        /// Number of times inter-region teleport failed due to server/client/network problems (e.g. viewer failed to
+        /// connect with destination region).
+        /// </summary>
+        /// <remarks>
+        /// This is not necessarily a problem for this simulator - in open-grid/hg conditions, viewer connectivity to
+        /// destination simulator is unknown.
+        /// </remarks>
+        private Stat m_interRegionTeleportFailures;
+
+        protected string m_ThisHomeURI;
+        protected string m_GatekeeperURI;
+
         protected bool m_Enabled = false;
 
         public Scene Scene { get; private set; }
@@ -70,10 +117,56 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         /// </summary>
         private EntityTransferStateMachine m_entityTransferStateMachine;
 
-        private ExpiringCache<UUID, ExpiringCache<ulong, DateTime>> m_bannedRegions =
-                new ExpiringCache<UUID, ExpiringCache<ulong, DateTime>>();
+        // For performance, we keed a cached of banned regions so we don't keep going
+        //    to the grid service.
+        private class BannedRegionCache
+        {
+            private ExpiringCache<UUID, ExpiringCache<ulong, DateTime>> m_bannedRegions =
+                    new ExpiringCache<UUID, ExpiringCache<ulong, DateTime>>();
+            ExpiringCache<ulong, DateTime> m_idCache;
+            DateTime m_banUntil;
+            public BannedRegionCache()
+            {
+            }
+            // Return 'true' if there is a valid ban entry for this agent in this region
+            public bool IfBanned(ulong pRegionHandle, UUID pAgentID)
+            {
+                bool ret = false;
+                if (m_bannedRegions.TryGetValue(pAgentID, out m_idCache))
+                {
+                    if (m_idCache.TryGetValue(pRegionHandle, out m_banUntil))
+                    {
+                        if (DateTime.Now < m_banUntil)
+                        {
+                            ret = true;
+                        }
+                    }
+                }
+                return ret;
+            }
+            // Add this agent in this region as a banned person
+            public void Add(ulong pRegionHandle, UUID pAgentID)
+            {
+                if (!m_bannedRegions.TryGetValue(pAgentID, out m_idCache))
+                {
+                    m_idCache = new ExpiringCache<ulong, DateTime>();
+                    m_bannedRegions.Add(pAgentID, m_idCache, TimeSpan.FromSeconds(45));
+                }
+                m_idCache.Add(pRegionHandle, DateTime.Now + TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
+            }
+            // Remove the agent from the region's banned list
+            public void Remove(ulong pRegionHandle, UUID pAgentID)
+            {
+                if (m_bannedRegions.TryGetValue(pAgentID, out m_idCache))
+                {
+                    m_idCache.Remove(pRegionHandle);
+                }
+            }
+        }
+        private BannedRegionCache m_bannedRegionCache = new BannedRegionCache();
 
         private IEventQueue m_eqModule;
+        private IRegionCombinerModule m_regionCombinerModule;
 
         #region ISharedRegionModule
 
@@ -107,11 +200,32 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         /// <param name="source"></param>
         protected virtual void InitialiseCommon(IConfigSource source)
         {
+            IConfig hypergridConfig = source.Configs["Hypergrid"];
+            if (hypergridConfig != null)
+            {
+                m_ThisHomeURI = hypergridConfig.GetString("HomeURI", string.Empty);
+                if (m_ThisHomeURI != string.Empty && !m_ThisHomeURI.EndsWith("/"))
+                    m_ThisHomeURI += '/';
+
+                m_GatekeeperURI = hypergridConfig.GetString("GatekeeperURI", string.Empty);
+                if (m_GatekeeperURI != string.Empty && !m_GatekeeperURI.EndsWith("/"))
+                    m_GatekeeperURI += '/';
+            }
+
             IConfig transferConfig = source.Configs["EntityTransfer"];
             if (transferConfig != null)
             {
+                DisableInterRegionTeleportCancellation 
+                    = transferConfig.GetBoolean("DisableInterRegionTeleportCancellation", false);
+
                 WaitForAgentArrivedAtDestination
                     = transferConfig.GetBoolean("wait_for_callback", WaitForAgentArrivedAtDestinationDefault);
+                
+                MaxTransferDistance = transferConfig.GetInt("max_distance", DefaultMaxTransferDistance);
+            }
+            else
+            {
+                MaxTransferDistance = DefaultMaxTransferDistance;
             }
 
             m_entityTransferStateMachine = new EntityTransferStateMachine(this);
@@ -130,19 +244,87 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             Scene = scene;
 
+            m_interRegionTeleportAttempts = 
+                new Stat(
+                    "InterRegionTeleportAttempts",
+                    "Number of inter-region teleports attempted.",
+                    "This does not count attempts which failed due to pre-conditions (e.g. target simulator refused access).\n"
+                        + "You can get successfully teleports by subtracting aborts, cancels and teleport failures from this figure.",
+                    "",
+                    "entitytransfer",
+                    Scene.Name,
+                    StatType.Push,
+                    null,
+                    StatVerbosity.Debug);
+
+            m_interRegionTeleportAborts = 
+                new Stat(
+                    "InterRegionTeleportAborts",
+                    "Number of inter-region teleports aborted due to client actions.",
+                    "The chief action is simultaneous logout whilst teleporting.",
+                    "",
+                    "entitytransfer",
+                    Scene.Name,
+                    StatType.Push,
+                    null,
+                    StatVerbosity.Debug);
+
+            m_interRegionTeleportCancels = 
+                new Stat(
+                    "InterRegionTeleportCancels",
+                    "Number of inter-region teleports cancelled by the client.",
+                    null,
+                    "",
+                    "entitytransfer",
+                    Scene.Name,
+                    StatType.Push,
+                    null,
+                    StatVerbosity.Debug);
+
+            m_interRegionTeleportFailures = 
+                new Stat(
+                    "InterRegionTeleportFailures",
+                    "Number of inter-region teleports that failed due to server/client/network issues.",
+                    "This number may not be very helpful in open-grid/hg situations as the network connectivity/quality of destinations is uncontrollable.",
+                    "",
+                    "entitytransfer",
+                    Scene.Name,
+                    StatType.Push,
+                    null,
+                    StatVerbosity.Debug);
+
+            StatsManager.RegisterStat(m_interRegionTeleportAttempts);
+            StatsManager.RegisterStat(m_interRegionTeleportAborts);
+            StatsManager.RegisterStat(m_interRegionTeleportCancels);
+            StatsManager.RegisterStat(m_interRegionTeleportFailures);
+
             scene.RegisterModuleInterface<IEntityTransferModule>(this);
             scene.EventManager.OnNewClient += OnNewClient;
         }
 
         protected virtual void OnNewClient(IClientAPI client)
         {
-            client.OnTeleportHomeRequest += TeleportHome;
+            client.OnTeleportHomeRequest += TriggerTeleportHome;
             client.OnTeleportLandmarkRequest += RequestTeleportLandmark;
+
+            if (!DisableInterRegionTeleportCancellation)
+                client.OnTeleportCancel += OnClientCancelTeleport;
+
+            client.OnConnectionClosed += OnConnectionClosed;
         }
 
         public virtual void Close() {}
 
-        public virtual void RemoveRegion(Scene scene) {}
+        public virtual void RemoveRegion(Scene scene) 
+        {
+            if (m_Enabled)
+            {
+                StatsManager.DeregisterStat(m_interRegionTeleportAttempts);
+                StatsManager.DeregisterStat(m_interRegionTeleportAborts);
+                StatsManager.DeregisterStat(m_interRegionTeleportCancels);
+                StatsManager.DeregisterStat(m_interRegionTeleportFailures);
+            }
+        }
 
         public virtual void RegionLoaded(Scene scene)
         {
@@ -150,12 +332,32 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 return;
 
             m_eqModule = Scene.RequestModuleInterface<IEventQueue>();
+            m_regionCombinerModule = Scene.RequestModuleInterface<IRegionCombinerModule>();
         }
 
         #endregion
 
         #region Agent Teleports
 
+        private void OnConnectionClosed(IClientAPI client)
+        {
+            if (client.IsLoggingOut && m_entityTransferStateMachine.UpdateInTransit(client.AgentId, AgentTransferState.Aborting))
+            {
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Aborted teleport request from {0} in {1} due to simultaneous logout", 
+                    client.Name, Scene.Name);
+            }
+        }
+
+        private void OnClientCancelTeleport(IClientAPI client)
+        {
+            m_entityTransferStateMachine.UpdateInTransit(client.AgentId, AgentTransferState.Cancelling);
+
+            m_log.DebugFormat(
+                "[ENTITY TRANSFER MODULE]: Received teleport cancel request from {0} in {1}", client.Name, Scene.Name);
+        }
+
+        // Attempt to teleport the ScenePresence to the specified position in the specified region (spec'ed by its handle).
         public void Teleport(ScenePresence sp, ulong regionHandle, Vector3 position, Vector3 lookAt, uint teleportFlags)
         {
             if (sp.Scene.Permissions.IsGridGod(sp.UUID))
@@ -167,13 +369,26 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             if (!sp.Scene.Permissions.CanTeleport(sp.UUID))
                 return;
 
-            // Reset animations; the viewer does that in teleports.
-            sp.Animator.ResetAnimations();
-
             string destinationRegionName = "(not found)";
 
+            // Record that this agent is in transit so that we can prevent simultaneous requests and do later detection
+            // of whether the destination region completes the teleport.
+            if (!m_entityTransferStateMachine.SetInTransit(sp.UUID))
+            {
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Ignoring teleport request of {0} {1} to {2}@{3} - agent is already in transit.",
+                    sp.Name, sp.UUID, position, regionHandle);
+
+                sp.ControllingClient.SendTeleportFailed("Previous teleport process incomplete.  Please retry shortly.");
+
+                return;
+            }
+
             try
             {
+                // Reset animations; the viewer does that in teleports.
+                sp.Animator.ResetAnimations();
+
                 if (regionHandle == sp.Scene.RegionInfo.RegionHandle)
                 {
                     destinationRegionName = sp.Scene.RegionInfo.RegionName;
@@ -182,12 +397,17 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 }
                 else // Another region possibly in another simulator
                 {
-                    GridRegion finalDestination;
-                    TeleportAgentToDifferentRegion(
-                        sp, regionHandle, position, lookAt, teleportFlags, out finalDestination);
-
-                    if (finalDestination != null)
-                        destinationRegionName = finalDestination.RegionName;
+                    GridRegion finalDestination = null;
+                    try
+                    {
+                        TeleportAgentToDifferentRegion(
+                            sp, regionHandle, position, lookAt, teleportFlags, out finalDestination);
+                    }
+                    finally
+                    {
+                        if (finalDestination != null)
+                            destinationRegionName = finalDestination.RegionName;
+                    }
                 }
             }
             catch (Exception e)
@@ -197,11 +417,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     sp.Name, sp.AbsolutePosition, sp.Scene.RegionInfo.RegionName, position, destinationRegionName,
                     e.Message, e.StackTrace);
 
-                // Make sure that we clear the in-transit flag so that future teleport attempts don't always fail.
-                m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
-
                 sp.ControllingClient.SendTeleportFailed("Internal error");
             }
+            finally
+            {
+                m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
+            }
         }
 
         /// <summary>
@@ -210,30 +431,21 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         /// <param name="sp"></param>
         /// <param name="position"></param>
         /// <param name="lookAt"></param>
-        /// <param name="teleportFlags"></param
+        /// <param name="teleportFlags"></param>
         private void TeleportAgentWithinRegion(ScenePresence sp, Vector3 position, Vector3 lookAt, uint teleportFlags)
         {
             m_log.DebugFormat(
                 "[ENTITY TRANSFER MODULE]: Teleport for {0} to {1} within {2}",
                 sp.Name, position, sp.Scene.RegionInfo.RegionName);
 
-            if (!m_entityTransferStateMachine.SetInTransit(sp.UUID))
-            {
-                m_log.DebugFormat(
-                    "[ENTITY TRANSFER MODULE]: Ignoring within region teleport request of {0} {1} to {2} - agent is already in transit.",
-                    sp.Name, sp.UUID, position);
-
-                return;
-            }
-
             // Teleport within the same region
-            if (IsOutsideRegion(sp.Scene, position) || position.Z < 0)
+            if (!sp.Scene.PositionIsInCurrentRegion(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);
+                    "[ENTITY TRANSFER MODULE]: RequestTeleportToLocation() was given an illegal position of {0} for avatar {1}, {2} in {3}.  Substituting {4}",
+                    position, sp.Name, sp.UUID, Scene.Name, emergencyPos);
 
                 position = emergencyPos;
             }
@@ -243,10 +455,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             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];
-            }
+            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)))
@@ -254,11 +463,15 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 position.Z = newPosZ;
             }
 
+            if (sp.Flying)
+                teleportFlags |= (uint)TeleportFlags.IsFlying;
+
             m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.Transferring);
 
             sp.ControllingClient.SendTeleportStart(teleportFlags);
 
             sp.ControllingClient.SendLocalTeleport(position, lookAt, teleportFlags);
+            sp.TeleportFlags = (Constants.TeleportFlags)teleportFlags;
             sp.Velocity = Vector3.Zero;
             sp.Teleport(position);
 
@@ -270,7 +483,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
 
             m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.CleaningUp);
-            m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
         }
 
         /// <summary>
@@ -286,21 +498,23 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             ScenePresence sp, ulong regionHandle, Vector3 position,
             Vector3 lookAt, uint teleportFlags, out GridRegion finalDestination)
         {
-            uint x = 0, y = 0;
-            Utils.LongToUInts(regionHandle, out x, out y);
-            GridRegion reg = Scene.GridService.GetRegionByPosition(sp.Scene.RegionInfo.ScopeID, (int)x, (int)y);
+            // Get destination region taking into account that the address could be an offset
+            //     region inside a varregion.
+            GridRegion reg = GetTeleportDestinationRegion(sp.Scene.GridService, sp.Scene.RegionInfo.ScopeID, regionHandle, ref position);
 
             if (reg != null)
             {
-                finalDestination = GetFinalDestination(reg);
+                string homeURI = Scene.GetAgentHomeURI(sp.ControllingClient.AgentId);
+
+                string message;
+                finalDestination = GetFinalDestination(reg, sp.ControllingClient.AgentId, homeURI, out message);
 
                 if (finalDestination == null)
                 {
-                    m_log.WarnFormat(
-                        "[ENTITY TRANSFER MODULE]: Final destination is having problems. Unable to teleport {0} {1}",
-                        sp.Name, sp.UUID);
+                    m_log.WarnFormat( "{0} Final destination is having problems. Unable to teleport {1} {2}: {3}",
+                                            LogHeader, sp.Name, sp.UUID, message);
 
-                    sp.ControllingClient.SendTeleportFailed("Problem at destination");
+                    sp.ControllingClient.SendTeleportFailed(message);
                     return;
                 }
 
@@ -321,10 +535,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     return;
                 }
 
+                if (message != null)
+                    sp.ControllingClient.SendAgentAlertMessage(message, true);
+
                 //
                 // This is it
                 //
-                DoTeleport(sp, reg, finalDestination, position, lookAt, teleportFlags);
+                DoTeleportInternal(sp, reg, finalDestination, position, lookAt, teleportFlags);
                 //
                 //
                 //
@@ -339,12 +556,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
                 // and set the map-tile to '(Offline)'
                 uint regX, regY;
-                Utils.LongToUInts(regionHandle, out regX, out regY);
+                Util.RegionHandleToRegionLoc(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
+                block.X = (ushort)regX;
+                block.Y = (ushort)regY;
+                block.Access = (byte)SimAccess.Down;
 
                 List<MapBlockData> blocks = new List<MapBlockData>();
                 blocks.Add(block);
@@ -352,6 +569,31 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
         }
 
+        // The teleport address could be an address in a subregion of a larger varregion.
+        // Find the real base region and adjust the teleport location to account for the
+        //    larger region.
+        private GridRegion GetTeleportDestinationRegion(IGridService gridService, UUID scope, ulong regionHandle, ref Vector3 position)
+        {
+            uint x = 0, y = 0;
+            Util.RegionHandleToWorldLoc(regionHandle, out x, out y);
+
+            // Compute the world location we're teleporting to
+            double worldX = (double)x + position.X;
+            double worldY = (double)y + position.Y;
+
+            // Find the region that contains the position
+            GridRegion reg = GetRegionContainingWorldLocation(gridService, scope, worldX, worldY);
+
+            if (reg != null)
+            {
+                // modify the position for the offset into the actual region returned
+                position.X += x - reg.RegionLocX;
+                position.Y += y - reg.RegionLocY;
+            }
+
+            return reg;
+        }
+
         // Nothing to validate here
         protected virtual bool ValidateGenericConditions(ScenePresence sp, GridRegion reg, GridRegion finalDestination, uint teleportFlags, out string reason)
         {
@@ -359,6 +601,32 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             return true;
         }
 
+        /// <summary>
+        /// Determines whether this instance is within the max transfer distance.
+        /// </summary>
+        /// <param name="sourceRegion"></param>
+        /// <param name="destRegion"></param>
+        /// <returns>
+        /// <c>true</c> if this instance is within max transfer distance; otherwise, <c>false</c>.
+        /// </returns>
+        private bool IsWithinMaxTeleportDistance(RegionInfo sourceRegion, GridRegion destRegion)
+        {
+            if(MaxTransferDistance == 0)
+                return true;
+
+//                        m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Source co-ords are x={0} y={1}", curRegionX, curRegionY);
+//
+//                        m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Final dest is x={0} y={1} {2}@{3}",
+//                            destRegionX, destRegionY, finalDestination.RegionID, finalDestination.ServerURI);
+
+            // Insanely, RegionLoc on RegionInfo is the 256m map co-ord whilst GridRegion.RegionLoc is the raw meters position.
+            return Math.Abs(sourceRegion.RegionLocX - destRegion.RegionCoordX) <= MaxTransferDistance
+                && Math.Abs(sourceRegion.RegionLocY - destRegion.RegionCoordY) <= MaxTransferDistance;
+        }
+
+        /// <summary>
+        /// Wraps DoTeleportInternal() and manages the transfer state.
+        /// </summary>
         public void DoTeleport(
             ScenePresence sp, GridRegion reg, GridRegion finalDestination,
             Vector3 position, Vector3 lookAt, uint teleportFlags)
@@ -370,18 +638,45 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 m_log.DebugFormat(
                     "[ENTITY TRANSFER MODULE]: Ignoring teleport request of {0} {1} to {2} ({3}) {4}/{5} - agent is already in transit.",
                     sp.Name, sp.UUID, reg.ServerURI, finalDestination.ServerURI, finalDestination.RegionName, position);
-
+                sp.ControllingClient.SendTeleportFailed("Agent is already in transit.");
                 return;
             }
+            
+            try
+            {
+                DoTeleportInternal(sp, reg, finalDestination, position, lookAt, teleportFlags);
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat(
+                    "[ENTITY TRANSFER MODULE]: Exception on teleport of {0} from {1}@{2} to {3}@{4}: {5}{6}",
+                    sp.Name, sp.AbsolutePosition, sp.Scene.RegionInfo.RegionName, position, finalDestination.RegionName,
+                    e.Message, e.StackTrace);
 
-            if (reg == null || finalDestination == null)
+                sp.ControllingClient.SendTeleportFailed("Internal error");
+            }
+            finally
             {
-                sp.ControllingClient.SendTeleportFailed("Unable to locate destination");
                 m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
+            }
+        }
 
+        /// <summary>
+        /// Teleports the agent to another region.
+        /// This method doesn't manage the transfer state; the caller must do that.
+        /// </summary>
+        private void DoTeleportInternal(
+            ScenePresence sp, GridRegion reg, GridRegion finalDestination,
+            Vector3 position, Vector3 lookAt, uint teleportFlags)
+        {
+            if (reg == null || finalDestination == null)
+            {
+                sp.ControllingClient.SendTeleportFailed("Unable to locate destination");
                 return;
             }
 
+            string homeURI = Scene.GetAgentHomeURI(sp.ControllingClient.AgentId);
+
             m_log.DebugFormat(
                 "[ENTITY TRANSFER MODULE]: Teleporting {0} {1} from {2} to {3} ({4}) {5}/{6}",
                 sp.Name, sp.UUID, sp.Scene.RegionInfo.RegionName,
@@ -389,10 +684,21 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             RegionInfo sourceRegion = sp.Scene.RegionInfo;
 
-            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);
+            if (!IsWithinMaxTeleportDistance(sourceRegion, finalDestination))
+            {
+                sp.ControllingClient.SendTeleportFailed(
+                    string.Format(
+                      "Can't teleport to {0} ({1},{2}) from {3} ({4},{5}), destination is more than {6} regions way",
+                      finalDestination.RegionName, finalDestination.RegionCoordX, finalDestination.RegionCoordY,
+                      sourceRegion.RegionName, sourceRegion.RegionLocX, sourceRegion.RegionLocY,
+                      MaxTransferDistance));
+
+                return;
+            }
+
+            uint newRegionX, newRegionY, oldRegionX, oldRegionY;
+            Util.RegionHandleToRegionLoc(reg.RegionHandle, out newRegionX, out newRegionY);
+            Util.RegionHandleToRegionLoc(sp.Scene.RegionInfo.RegionHandle, out oldRegionX, out oldRegionY);
 
             ulong destinationHandle = finalDestination.RegionHandle;
 
@@ -400,11 +706,9 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             // 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)
+            if (endPoint == null || endPoint.Address == null)
             {
                 sp.ControllingClient.SendTeleportFailed("Remote Region appears to be down");
-                m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
 
                 return;
             }
@@ -412,35 +716,41 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             if (!sp.ValidateAttachments())
                 m_log.DebugFormat(
                     "[ENTITY TRANSFER MODULE]: Failed validation of all attachments for teleport of {0} from {1} to {2}.  Continuing.",
-                    sp.Name, sp.Scene.RegionInfo.RegionName, finalDestination.RegionName);
-
-//                if (!sp.ValidateAttachments())
-//                {
-//                    sp.ControllingClient.SendTeleportFailed("Inconsistent attachment state");
-//                    return;
-//                }
+                    sp.Name, sp.Scene.Name, finalDestination.RegionName);
 
             string reason;
-            string version;
+            EntityTransferContext ctx = new EntityTransferContext();
+
             if (!Scene.SimulationService.QueryAccess(
-                finalDestination, sp.ControllingClient.AgentId, Vector3.Zero, out version, out reason))
+                finalDestination, sp.ControllingClient.AgentId, homeURI, true, position, sp.Scene.GetFormatsOffered(), ctx, out reason))
             {
                 sp.ControllingClient.SendTeleportFailed(reason);
-                m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
 
                 m_log.DebugFormat(
-                    "[ENTITY TRANSFER MODULE]: {0} was stopped from teleporting from {1} to {2} because {3}",
-                    sp.Name, sp.Scene.RegionInfo.RegionName, finalDestination.RegionName, reason);
+                    "[ENTITY TRANSFER MODULE]: {0} was stopped from teleporting from {1} to {2} because: {3}",
+                    sp.Name, sp.Scene.Name, finalDestination.RegionName, reason);
 
                 return;
             }
 
-            m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Destination is running version {0}", version);
+            // Before this point, teleport 'failure' is due to checkable pre-conditions such as whether the target
+            // simulator can be found and is explicitly prepared to allow access.  Therefore, we will not count these
+            // as server attempts.
+            m_interRegionTeleportAttempts.Value++;
+
+            m_log.DebugFormat(
+                "[ENTITY TRANSFER MODULE]: {0} transfer protocol version to {1} is {2} / {3}", 
+                sp.Scene.Name, finalDestination.RegionName, ctx.OutboundVersion, ctx.InboundVersion);
 
             // Fixing a bug where teleporting while sitting results in the avatar ending up removed from
             // both regions
             if (sp.ParentID != (uint)0)
                 sp.StandUp();
+            else if (sp.Flying)
+                teleportFlags |= (uint)TeleportFlags.IsFlying;
+
+            if (DisableInterRegionTeleportCancellation)
+                teleportFlags |= (uint)TeleportFlags.DisableCancel;
 
             // At least on LL 3.3.4, this is not strictly necessary - a teleport will succeed without sending this to
             // the viewer.  However, it might mean that the viewer does not see the black teleport screen (untested).
@@ -454,13 +764,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             // 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;
+            agentCircuit.Appearance = new AvatarAppearance();
+            agentCircuit.Appearance.PackLegacyWearables = true;
             if (currentAgentCircuit != null)
             {
                 agentCircuit.ServiceURLs = currentAgentCircuit.ServiceURLs;
@@ -471,23 +780,66 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 agentCircuit.Id0 = currentAgentCircuit.Id0;
             }
 
-            if (NeedsNewAgent(sp.DrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY))
+            // if (NeedsNewAgent(sp.DrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY))
+            float dist = (float)Math.Max(sp.Scene.DefaultDrawDistance,
+                (float)Math.Max(sp.Scene.RegionInfo.RegionSizeX, sp.Scene.RegionInfo.RegionSizeY));
+            if (NeedsNewAgent(dist, oldRegionX, newRegionX, oldRegionY, newRegionY))
             {
                 // brand new agent, let's create a new caps seed
                 agentCircuit.CapsPath = CapsUtil.GetRandomCapsObjectPath();
             }
 
-            // Let's create an agent there if one doesn't exist yet. 
+            // We're going to fallback to V1 if the destination gives us anything smaller than 0.2
+            if (ctx.OutboundVersion >= 0.2f)
+                TransferAgent_V2(sp, agentCircuit, reg, finalDestination, endPoint, teleportFlags, oldRegionX, newRegionX, oldRegionY, newRegionY, ctx, out reason);
+            else
+                TransferAgent_V1(sp, agentCircuit, reg, finalDestination, endPoint, teleportFlags, oldRegionX, newRegionX, oldRegionY, newRegionY, ctx, out reason);           
+        }
+
+        private void TransferAgent_V1(ScenePresence sp, AgentCircuitData agentCircuit, GridRegion reg, GridRegion finalDestination,
+            IPEndPoint endPoint, uint teleportFlags, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY, EntityTransferContext ctx, out string reason)
+        {
+            ulong destinationHandle = finalDestination.RegionHandle;
+            AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
+
+            m_log.DebugFormat(
+                "[ENTITY TRANSFER MODULE]: Using TP V1 for {0} going from {1} to {2}", 
+                sp.Name, Scene.Name, finalDestination.RegionName);
+
+             // Let's create an agent there if one doesn't exist yet. 
+            // NOTE: logout will always be false for a non-HG teleport.
             bool logout = false;
             if (!CreateAgent(sp, reg, finalDestination, agentCircuit, teleportFlags, out reason, out logout))
             {
-                sp.ControllingClient.SendTeleportFailed(String.Format("Teleport refused: {0}", reason));
-                m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
+                m_interRegionTeleportFailures.Value++;
 
                 m_log.DebugFormat(
                     "[ENTITY TRANSFER MODULE]: Teleport of {0} from {1} to {2} was refused because {3}",
                     sp.Name, sp.Scene.RegionInfo.RegionName, finalDestination.RegionName, reason);
 
+                sp.ControllingClient.SendTeleportFailed(reason);
+
+                return;
+            }
+
+            if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Cancelling)
+            {
+                m_interRegionTeleportCancels.Value++;
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Cancelled teleport of {0} to {1} from {2} after CreateAgent on client request",
+                    sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                return;
+            }
+            else if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Aborting)
+            {
+                m_interRegionTeleportAborts.Value++;
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Aborted teleport of {0} to {1} from {2} after CreateAgent due to previous client close.",
+                    sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
                 return;
             }
 
@@ -497,9 +849,16 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             // OK, it got this agent. Let's close some child agents
             sp.CloseChildAgents(newRegionX, newRegionY);
 
-            IClientIPEndpoint ipepClient;  
-            if (NeedsNewAgent(sp.DrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY))
+            IClientIPEndpoint ipepClient;
+            string capsPath = String.Empty;
+            float dist = (float)Math.Max(sp.Scene.DefaultDrawDistance,
+                (float)Math.Max(sp.Scene.RegionInfo.RegionSizeX, sp.Scene.RegionInfo.RegionSizeY));
+            if (NeedsNewAgent(dist, oldRegionX, newRegionX, oldRegionY, newRegionY))
             {
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Determined that region {0} at {1},{2} needs new child agent for incoming agent {3} from {4}",
+                    finalDestination.RegionName, newRegionX, newRegionY, sp.Name, Scene.Name);
+
                 //sp.ControllingClient.SendTeleportProgress(teleportFlags, "Creating agent...");
                 #region IP Translation for NAT
                 // Uses ipepClient above
@@ -512,21 +871,30 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
                 if (m_eqModule != null)
                 {
-                    m_eqModule.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
+                    // The EnableSimulator message makes the client establish a connection with the destination
+                    // simulator by sending the initial UseCircuitCode UDP packet to the destination containing the
+                    // correct circuit code.
+                    m_eqModule.EnableSimulator(destinationHandle, endPoint, sp.UUID,
+                                        finalDestination.RegionSizeX, finalDestination.RegionSizeY);
+                    m_log.DebugFormat("{0} Sent EnableSimulator. regName={1}, size=<{2},{3}>", LogHeader,
+                        finalDestination.RegionName, finalDestination.RegionSizeX, finalDestination.RegionSizeY);
+
+                    // XXX: Is this wait necessary?  We will always end up waiting on UpdateAgent for the destination
+                    // simulator to confirm that it has established communication with the viewer.
                     Thread.Sleep(200);
 
                     // At least on LL 3.3.4 for teleports between different regions on the same simulator this appears
                     // unnecessary - teleport will succeed and SEED caps will be requested without it (though possibly
                     // only on TeleportFinish).  This is untested for region teleport between different simulators
                     // though this probably also works.
-                    m_eqModule.EstablishAgentCommunication(sp.UUID, endPoint, capsPath);
+                    m_eqModule.EstablishAgentCommunication(sp.UUID, endPoint, capsPath, finalDestination.RegionHandle,
+                                        finalDestination.RegionSizeX, finalDestination.RegionSizeY);
                 }
                 else
                 {
+                    // XXX: This is a little misleading since we're information the client of its avatar destination,
+                    // which may or may not be a neighbour region of the source region.  This path is probably little
+                    // used anyway (with EQ being the one used).  But it is currently being used for test code.
                     sp.ControllingClient.InformClientOfNeighbour(destinationHandle, endPoint);
                 }
             }
@@ -539,31 +907,77 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             // Let's send a full update of the agent. This is a synchronous call.
             AgentData agent = new AgentData();
             sp.CopyTo(agent);
-            agent.Position = position;
+            if (ctx.OutboundVersion < 0.5f)
+                agent.Appearance.PackLegacyWearables = true;
+            agent.Position = agentCircuit.startpos;
             SetCallbackURL(agent, sp.Scene.RegionInfo);
 
-            //sp.ControllingClient.SendTeleportProgress(teleportFlags, "Updating agent...");
 
+            // We will check for an abort before UpdateAgent since UpdateAgent will require an active viewer to 
+            // establish th econnection to the destination which makes it return true.
+            if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Aborting)
+            {
+                m_interRegionTeleportAborts.Value++;
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Aborted teleport of {0} to {1} from {2} before UpdateAgent",
+                    sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                return;
+            }
+
+            // A common teleport failure occurs when we can send CreateAgent to the 
+            // destination region but the viewer cannot establish the connection (e.g. due to network issues between
+            // the viewer and the destination).  In this case, UpdateAgent timesout after 10 seconds, although then
+            // there's a further 10 second wait whilst we attempt to tell the destination to delete the agent in Fail().
             if (!UpdateAgent(reg, finalDestination, agent, sp))
             {
-                // Region doesn't take it
+                if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Aborting)
+                {
+                    m_interRegionTeleportAborts.Value++;
+
+                    m_log.DebugFormat(
+                        "[ENTITY TRANSFER MODULE]: Aborted teleport of {0} to {1} from {2} after UpdateAgent due to previous client close.",
+                        sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                    return;
+                }
+
                 m_log.WarnFormat(
-                    "[ENTITY TRANSFER MODULE]: UpdateAgent failed on teleport of {0} to {1} from {2}.  Returning avatar to source region.",
-                    sp.Name, finalDestination.RegionName, sp.Scene.RegionInfo.RegionName);
-                
-                Fail(sp, finalDestination, logout);
+                    "[ENTITY TRANSFER MODULE]: UpdateAgent failed on teleport of {0} to {1}.  Keeping avatar in {2}",
+                    sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                Fail(sp, finalDestination, logout, currentAgentCircuit.SessionID.ToString(), "Connection between viewer and destination region could not be established.");
                 return;
             }
 
-            sp.ControllingClient.SendTeleportProgress(teleportFlags | (uint)TeleportFlags.DisableCancel, "sending_dest");
+            if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Cancelling)
+            {
+                m_interRegionTeleportCancels.Value++;
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Cancelled teleport of {0} to {1} from {2} after UpdateAgent on client request",
+                    sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                CleanupFailedInterRegionTeleport(sp, currentAgentCircuit.SessionID.ToString(), finalDestination);
+
+                return;
+            }
 
             m_log.DebugFormat(
                 "[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} from {1} to {2}",
                 capsPath, sp.Scene.RegionInfo.RegionName, sp.Name);
 
+            // We need to set this here to avoid an unlikely race condition when teleporting to a neighbour simulator,
+            // where that neighbour simulator could otherwise request a child agent create on the source which then 
+            // closes our existing agent which is still signalled as root.
+            sp.IsChildAgent = true;
+
+            // OK, send TPFinish to the client, so that it starts the process of contacting the destination region
             if (m_eqModule != null)
             {
-                m_eqModule.TeleportFinishEvent(destinationHandle, 13, endPoint, 0, teleportFlags, capsPath, sp.UUID);
+                m_eqModule.TeleportFinishEvent(destinationHandle, 13, endPoint, 0, teleportFlags, capsPath, sp.UUID,
+                            finalDestination.RegionSizeX, finalDestination.RegionSizeY);
             }
             else
             {
@@ -571,31 +985,43 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                                                             teleportFlags, capsPath);
             }
 
-            // Let's set this to true tentatively. This does not trigger OnChildAgent
-            sp.IsChildAgent = true;
-
             // 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 close things here.
             if (!m_entityTransferStateMachine.WaitForAgentArrivedAtDestination(sp.UUID))
             {
+                if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Aborting)
+                {
+                    m_interRegionTeleportAborts.Value++;
+
+                    m_log.DebugFormat(
+                        "[ENTITY TRANSFER MODULE]: Aborted teleport of {0} to {1} from {2} after WaitForAgentArrivedAtDestination due to previous client close.",
+                        sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                    return;
+                }
+
                 m_log.WarnFormat(
                     "[ENTITY TRANSFER MODULE]: Teleport of {0} to {1} from {2} failed due to no callback from destination region.  Returning avatar to source region.",
                     sp.Name, finalDestination.RegionName, sp.Scene.RegionInfo.RegionName);
-                
-                Fail(sp, finalDestination, logout);                   
+
+                Fail(sp, finalDestination, logout, currentAgentCircuit.SessionID.ToString(), "Destination region did not signal teleport completion.");
+
                 return;
             }
 
             m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.CleaningUp);
 
+/*
+            // TODO: This may be 0.6. Check if still needed
             // For backwards compatibility
-            if (version == "Unknown" || version == string.Empty)
+            if (version == 0f)
             {
                 // CrossAttachmentsIntoNewRegion is a synchronous call. We shouldn't need to wait after it
                 m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Old simulator, sending attachments one by one...");
                 CrossAttachmentsIntoNewRegion(finalDestination, sp, true);
             }
+*/
 
             // May need to logout or other cleanup
             AgentHasMovedAway(sp, logout);
@@ -606,12 +1032,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             // Now let's make it officially a child agent
             sp.MakeChildAgent();
 
-//                sp.Scene.CleanDroppedAttachments();
-
             // Finally, let's close this previously-known-as-root agent, when the jump is outside the view zone
 
-            if (NeedsClosing(sp.DrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
+            if (NeedsClosing(sp.Scene.DefaultDrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
             {
+                if (!sp.Scene.IncomingPreCloseClient(sp))
+                    return;
+
                 // We need to delay here because Imprudence viewers, unlike v1 or v3, have a short (<200ms, <500ms) delay before
                 // they regard the new region as the current region after receiving the AgentMovementComplete
                 // response.  If close is sent before then, it will cause the viewer to quit instead.
@@ -620,51 +1047,243 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 // an agent cannot teleport back to this region if it has teleported away.
                 Thread.Sleep(2000);
 
-                sp.Scene.IncomingCloseAgent(sp.UUID, false);
+                sp.Scene.CloseAgent(sp.UUID, false);
             }
             else
             {
                 // now we have a child agent in this region. 
                 sp.Reset();
             }
+        }
 
-            // Commented pending deletion since this method no longer appears to do anything at all
-//            // 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);
-//            }
+        private void TransferAgent_V2(ScenePresence sp, AgentCircuitData agentCircuit, GridRegion reg, GridRegion finalDestination,
+            IPEndPoint endPoint, uint teleportFlags, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY, EntityTransferContext ctx, out string reason)
+        {
+            ulong destinationHandle = finalDestination.RegionHandle;
+            AgentCircuitData currentAgentCircuit = sp.Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
+
+            // Let's create an agent there if one doesn't exist yet. 
+            // NOTE: logout will always be false for a non-HG teleport.
+            bool logout = false;
+            if (!CreateAgent(sp, reg, finalDestination, agentCircuit, teleportFlags, out reason, out logout))
+            {
+                m_interRegionTeleportFailures.Value++;
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Teleport of {0} from {1} to {2} was refused because {3}",
+                    sp.Name, sp.Scene.RegionInfo.RegionName, finalDestination.RegionName, reason);
+
+                sp.ControllingClient.SendTeleportFailed(reason);
+
+                return;
+            }
+
+            if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Cancelling)
+            {
+                m_interRegionTeleportCancels.Value++;
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Cancelled teleport of {0} to {1} from {2} after CreateAgent on client request",
+                    sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                return;
+            }
+            else if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Aborting)
+            {
+                m_interRegionTeleportAborts.Value++;
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Aborted teleport of {0} to {1} from {2} after CreateAgent due to previous client close.",
+                    sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                return;
+            }
+
+            // Past this point we have to attempt clean up if the teleport fails, so update transfer state.
+            m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.Transferring);
+
+            IClientIPEndpoint ipepClient;
+            string capsPath = String.Empty;
+            float dist = (float)Math.Max(sp.Scene.DefaultDrawDistance, 
+                (float)Math.Max(sp.Scene.RegionInfo.RegionSizeX, sp.Scene.RegionInfo.RegionSizeY));
+            if (NeedsNewAgent(dist, oldRegionX, newRegionX, oldRegionY, newRegionY))
+            {
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Determined that region {0} at {1},{2} needs new child agent for agent {3} from {4}",
+                    finalDestination.RegionName, newRegionX, newRegionY, sp.Name, Scene.Name);
+
+                //sp.ControllingClient.SendTeleportProgress(teleportFlags, "Creating agent...");
+                #region IP Translation for NAT
+                // Uses ipepClient above
+                if (sp.ClientView.TryGet(out ipepClient))
+                {
+                    endPoint.Address = NetworkUtil.GetIPFor(ipepClient.EndPoint, endPoint.Address);
+                }
+                #endregion
+                capsPath = finalDestination.ServerURI + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
+            }
+            else
+            {
+                agentCircuit.CapsPath = sp.Scene.CapsModule.GetChildSeed(sp.UUID, reg.RegionHandle);
+                capsPath = finalDestination.ServerURI + CapsUtil.GetCapsSeedPath(agentCircuit.CapsPath);
+            }
+
+            // We need to set this here to avoid an unlikely race condition when teleporting to a neighbour simulator,
+            // where that neighbour simulator could otherwise request a child agent create on the source which then 
+            // closes our existing agent which is still signalled as root.
+            //sp.IsChildAgent = true;
+
+            // New protocol: send TP Finish directly, without prior ES or EAC. That's what happens in the Linden grid
+            if (m_eqModule != null)
+                m_eqModule.TeleportFinishEvent(destinationHandle, 13, endPoint, 0, teleportFlags, capsPath, sp.UUID,
+                                    finalDestination.RegionSizeX, finalDestination.RegionSizeY);
+            else
+                sp.ControllingClient.SendRegionTeleport(destinationHandle, 13, endPoint, 4,
+                                                            teleportFlags, capsPath);
+
+            m_log.DebugFormat(
+                "[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} from {1} to {2}",
+                capsPath, sp.Scene.RegionInfo.RegionName, sp.Name);
+
+            // Let's send a full update of the agent. 
+            AgentData agent = new AgentData();
+            sp.CopyTo(agent);
+            if (ctx.OutboundVersion < 0.5f)
+                agent.Appearance.PackLegacyWearables = true;
+            agent.Position = agentCircuit.startpos;
+            agent.SenderWantsToWaitForRoot = true;
+            //SetCallbackURL(agent, sp.Scene.RegionInfo);
+
+            // Reset the do not close flag.  This must be done before the destination opens child connections (here
+            // triggered by UpdateAgent) to avoid race conditions.  However, we also want to reset it as late as possible
+            // to avoid a situation where an unexpectedly early call to Scene.NewUserConnection() wrongly results
+            // in no close.
+            sp.DoNotCloseAfterTeleport = false;
+
+            // Send the Update. If this returns true, we know the client has contacted the destination
+            // via CompleteMovementIntoRegion, so we can let go.
+            // If it returns false, something went wrong, and we need to abort.
+            if (!UpdateAgent(reg, finalDestination, agent, sp))
+            {
+                if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Aborting)
+                {
+                    m_interRegionTeleportAborts.Value++;
+
+                    m_log.DebugFormat(
+                        "[ENTITY TRANSFER MODULE]: Aborted teleport of {0} to {1} from {2} after UpdateAgent due to previous client close.",
+                        sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                    return;
+                }
+
+                m_log.WarnFormat(
+                    "[ENTITY TRANSFER MODULE]: UpdateAgent failed on teleport of {0} to {1}.  Keeping avatar in {2}",
+                    sp.Name, finalDestination.RegionName, sp.Scene.Name);
+
+                Fail(sp, finalDestination, logout, currentAgentCircuit.SessionID.ToString(), "Connection between viewer and destination region could not be established.");
+                return;
+            }
+            
+            m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.CleaningUp);
+
+            // Need to signal neighbours whether child agents may need closing irrespective of whether this
+            // one needed closing.  We also need to close child agents as quickly as possible to avoid complicated
+            // race conditions with rapid agent releporting (e.g. from A1 to a non-neighbour B, back
+            // to a neighbour A2 then off to a non-neighbour C).  Closing child agents any later requires complex
+            // distributed checks to avoid problems in rapid reteleporting scenarios and where child agents are
+            // abandoned without proper close by viewer but then re-used by an incoming connection.
+            sp.CloseChildAgents(newRegionX, newRegionY);
+
+            // May need to logout or other cleanup
+            AgentHasMovedAway(sp, logout);
+
+            // Well, this is it. The agent is over there.
+            KillEntity(sp.Scene, sp.LocalId);
 
-            m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
+            // Now let's make it officially a child agent
+            sp.MakeChildAgent();
+
+            // Finally, let's close this previously-known-as-root agent, when the jump is outside the view zone
+            if (NeedsClosing(sp.Scene.DefaultDrawDistance, oldRegionX, newRegionX, oldRegionY, newRegionY, reg))
+            {
+                if (!sp.Scene.IncomingPreCloseClient(sp))
+                    return;
+
+                // RED ALERT!!!!
+                // PLEASE DO NOT DECREASE THIS WAIT TIME UNDER ANY CIRCUMSTANCES.
+                // THE VIEWERS SEEM TO NEED SOME TIME AFTER RECEIVING MoveAgentIntoRegion
+                // BEFORE THEY SETTLE IN THE NEW REGION.
+                // DECREASING THE WAIT TIME HERE WILL EITHER RESULT IN A VIEWER CRASH OR
+                // IN THE AVIE BEING PLACED IN INFINITY FOR A COUPLE OF SECONDS.
+                Thread.Sleep(15000);
+            
+                // OK, it got this agent. Let's close everything
+                // If we shouldn't close the agent due to some other region renewing the connection 
+                // then this will be handled in IncomingCloseAgent under lock conditions
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Closing agent {0} in {1} after teleport", sp.Name, Scene.Name);
+
+                sp.Scene.CloseAgent(sp.UUID, false);
+            }
+            else
+            {
+                // now we have a child agent in this region. 
+                sp.Reset();
+            }
         }
 
-        protected virtual void Fail(ScenePresence sp, GridRegion finalDestination, bool logout)
+        /// <summary>
+        /// Clean up an inter-region teleport that did not complete, either because of simulator failure or cancellation.
+        /// </summary>
+        /// <remarks>
+        /// All operations here must be idempotent so that we can call this method at any point in the teleport process
+        /// up until we send the TeleportFinish event quene event to the viewer.
+        /// <remarks>
+        /// <param name='sp'> </param>
+        /// <param name='finalDestination'></param>
+        protected virtual void CleanupFailedInterRegionTeleport(ScenePresence sp, string auth_token, GridRegion finalDestination)
         {
             m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.CleaningUp);
 
-            // Client never contacted destination. Let's restore everything back
-            sp.ControllingClient.SendTeleportFailed("Problems connecting to destination.");
+            if (sp.IsChildAgent) // We had set it to child before attempted TP (V1)
+            {
+                sp.IsChildAgent = false;
+                ReInstantiateScripts(sp);
 
-            // Fail. Reset it back
-            sp.IsChildAgent = false;
-            ReInstantiateScripts(sp);
+                EnableChildAgents(sp);
+            }
+            // Finally, kill the agent we just created at the destination.
+            // XXX: Possibly this should be done asynchronously.
+            Scene.SimulationService.CloseAgent(finalDestination, sp.UUID, auth_token);
+        }
 
-            EnableChildAgents(sp);
+        /// <summary>
+        /// Signal that the inter-region teleport failed and perform cleanup.
+        /// </summary>
+        /// <param name='sp'></param>
+        /// <param name='finalDestination'></param>
+        /// <param name='logout'></param>
+        /// <param name='reason'>Human readable reason for teleport failure.  Will be sent to client.</param>
+        protected virtual void Fail(ScenePresence sp, GridRegion finalDestination, bool logout, string auth_code, string reason)
+        {
+            CleanupFailedInterRegionTeleport(sp, auth_code, finalDestination);
 
-            // Finally, kill the agent we just created at the destination.
-            Scene.SimulationService.CloseAgent(finalDestination, sp.UUID);
+            m_interRegionTeleportFailures.Value++;
 
-            sp.Scene.EventManager.TriggerTeleportFail(sp.ControllingClient, logout);
+            sp.ControllingClient.SendTeleportFailed(
+                string.Format(
+                    "Problems connecting to destination {0}, reason: {1}", finalDestination.RegionName, reason));
 
-            m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
+            sp.Scene.EventManager.TriggerTeleportFail(sp.ControllingClient, logout);
         }
 
         protected virtual bool CreateAgent(ScenePresence sp, GridRegion reg, GridRegion finalDestination, AgentCircuitData agentCircuit, uint teleportFlags, out string reason, out bool logout)
         {
+            GridRegion source = new GridRegion(Scene.RegionInfo);
+            source.RawServerURI = m_GatekeeperURI;
+
             logout = false;
-            bool success = Scene.SimulationService.CreateAgent(finalDestination, agentCircuit, teleportFlags, out reason);
+            bool success = Scene.SimulationService.CreateAgent(source, finalDestination, agentCircuit, teleportFlags, out reason);
 
             if (success)
                 sp.Scene.EventManager.TriggerTeleportStart(sp.ControllingClient, reg, finalDestination, teleportFlags, logout);
@@ -702,14 +1321,32 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             scene.SendKillObject(new List<uint> { localID });
         }
 
-        protected virtual GridRegion GetFinalDestination(GridRegion region)
+        protected virtual GridRegion GetFinalDestination(GridRegion region, UUID agentID, string agentHomeURI, out string message)
         {
+            message = null;
             return region;
         }
 
+        // This returns 'true' if the new region already has a child agent for our
+        //    incoming agent. The implication is that, if 'false', we have to create  the
+        //    child and then teleport into the region.
         protected virtual bool NeedsNewAgent(float drawdist, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY)
         {
-            return Util.IsOutsideView(drawdist, oldRegionX, newRegionX, oldRegionY, newRegionY);
+            if (m_regionCombinerModule != null && m_regionCombinerModule.IsRootForMegaregion(Scene.RegionInfo.RegionID))
+            {
+                Vector2 swCorner, neCorner;
+                GetMegaregionViewRange(out swCorner, out neCorner);
+
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Megaregion view of {0} is from {1} to {2} with new agent check for {3},{4}",
+                    Scene.Name, swCorner, neCorner, newRegionX, newRegionY);
+
+                return !(newRegionX >= swCorner.X && newRegionX <= neCorner.X && newRegionY >= swCorner.Y && newRegionY <= neCorner.Y);
+            }
+            else
+            {
+                return Util.IsOutsideView(drawdist, oldRegionX, newRegionX, oldRegionY, newRegionY);
+            }
         }
 
         protected virtual bool NeedsClosing(float drawdist, uint oldRegionX, uint newRegionX, uint oldRegionY, uint newRegionY, GridRegion reg)
@@ -717,20 +1354,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             return Util.IsOutsideView(drawdist, 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 Landmark Teleport
@@ -758,7 +1381,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         #region Teleport Home
 
-        public virtual void TeleportHome(UUID id, IClientAPI client)
+        public virtual void TriggerTeleportHome(UUID id, IClientAPI client)
+        {
+            TeleportHome(id, client);
+        }
+
+        public virtual bool TeleportHome(UUID id, IClientAPI client)
         {
             m_log.DebugFormat(
                 "[ENTITY TRANSFER MODULE]: Request to teleport {0} {1} home", client.Name, client.AgentId);
@@ -768,12 +1396,20 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             if (uinfo != null)
             {
+                if (uinfo.HomeRegionID == UUID.Zero)
+                {
+                    // can't find the Home region: Tell viewer and abort
+                    m_log.ErrorFormat("{0} No grid user info found for {1} {2}. Cannot send home.",
+                                    LogHeader, client.Name, client.AgentId);
+                    client.SendTeleportFailed("You don't have a home position set.");
+                    return false;
+                }
                 GridRegion regionInfo = Scene.GridService.GetRegionByUUID(UUID.Zero, uinfo.HomeRegionID);
                 if (regionInfo == null)
                 {
                     // can't find the Home region: Tell viewer and abort
                     client.SendTeleportFailed("Your home region could not be found.");
-                    return;
+                    return false;
                 }
                 
                 m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Home region of {0} is {1} ({2}-{3})",
@@ -783,13 +1419,14 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 ((Scene)(client.Scene)).RequestTeleportLocation(
                     client, regionInfo.RegionHandle, uinfo.HomePosition, uinfo.HomeLookAt,
                     (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaHome));
+                return true;
             }
             else
             {
-                m_log.ErrorFormat(
-                    "[ENTITY TRANSFER MODULE]: No grid user information found for {0} {1}.  Cannot send home.",
-                    client.Name, client.AgentId);
+                // can't find the Home region: Tell viewer and abort
+                client.SendTeleportFailed("Your home region could not be found.");
             }
+            return false;
         }
 
         #endregion
@@ -797,230 +1434,112 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         #region Agent Crossings
 
-        public bool Cross(ScenePresence agent, bool isFlying)
+        // Given a position relative to the current region (which has previously been tested to
+        //    see that it is actually outside the current region), find the new region that the
+        //    point is actually in.
+        // Returns the coordinates and information of the new region or 'null' of it doesn't exist.
+        public GridRegion GetDestination(Scene scene, UUID agentID, Vector3 pos,
+                                            EntityTransferContext ctx, out Vector3 newpos, out string failureReason)
         {
-            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 into new region to place avatar
-            const float enterDistance = 0.5f;
+            newpos = pos;
+            failureReason = string.Empty;
+            string homeURI = scene.GetAgentHomeURI(agentID);
 
-            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
-                    {
-                        agent.IsInTransit = true;
-
-                        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 true;
-                    }
-                }
-
-                Border ba = scene.GetCrossedBorder(pos + westCross, Cardinals.W);
-                if (ba.TriggerRegionX == 0 && ba.TriggerRegionY == 0)
-                {
-                    neighbourx--;
-                    newpos.X = Constants.RegionSize - enterDistance;
-                }
-                else
-                {
-                    agent.IsInTransit = true;
+//            m_log.DebugFormat(
+//                "[ENTITY TRANSFER MODULE]: Crossing agent {0} at pos {1} in {2}", agent.Name, pos, scene.Name);
 
-                    neighboury = ba.TriggerRegionY;
-                    neighbourx = ba.TriggerRegionX;
+            // Compute world location of the object's position
+            double presenceWorldX = (double)scene.RegionInfo.WorldLocX + pos.X;
+            double presenceWorldY = (double)scene.RegionInfo.WorldLocY + pos.Y;
 
-                    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);
+            // Call the grid service to lookup the region containing the new position.
+            GridRegion neighbourRegion = GetRegionContainingWorldLocation(scene.GridService, scene.RegionInfo.ScopeID,
+                                                        presenceWorldX, presenceWorldY, 
+                                                        Math.Max(scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY));
 
-                    return true;
-                }
-
-            }
-            else if (scene.TestBorderCross(pos + eastCross, Cardinals.E))
+            if (neighbourRegion != null)
             {
-                Border b = scene.GetCrossedBorder(pos + eastCross, Cardinals.E);
-                neighbourx += (uint)(int)(b.BorderLine.Z / (int)Constants.RegionSize);
-                newpos.X = enterDistance;
+                // Compute the entity's position relative to the new region
+                newpos = new Vector3((float)(presenceWorldX - (double)neighbourRegion.RegionLocX),
+                                      (float)(presenceWorldY - (double)neighbourRegion.RegionLocY),
+                                      pos.Z);
 
-                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
-                    {
-                        agent.IsInTransit = true;
-
-                        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 true;
-                    }
-                }
-                else if (scene.TestBorderCross(pos + northCross, Cardinals.N))
+                if (m_bannedRegionCache.IfBanned(neighbourRegion.RegionHandle, agentID))
                 {
-                    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;
+                    failureReason = "Cannot region cross into banned parcel";
+                    neighbourRegion = null;
                 }
                 else
                 {
-                    agent.IsInTransit = true;
-
-                    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 true;
+                    // If not banned, make sure this agent is not in the list.
+                    m_bannedRegionCache.Remove(neighbourRegion.RegionHandle, agentID);
                 }
-            }
-            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;
-            }
-            */
-
-            ulong neighbourHandle = Utils.UIntsToLong((uint)(neighbourx * Constants.RegionSize), (uint)(neighboury * Constants.RegionSize));
-
-            int x = (int)(neighbourx * Constants.RegionSize), y = (int)(neighboury * Constants.RegionSize);
-
-            ExpiringCache<ulong, DateTime> r;
-            DateTime banUntil;
-
-            if (m_bannedRegions.TryGetValue(agent.ControllingClient.AgentId, out r))
-            {
-                if (r.TryGetValue(neighbourHandle, out banUntil))
+                // Check to see if we have access to the target region.
+                if (neighbourRegion != null
+                    && !scene.SimulationService.QueryAccess(neighbourRegion, agentID, homeURI, false, newpos, scene.GetFormatsOffered(), ctx, out failureReason))
                 {
-                    if (DateTime.Now < banUntil)
-                        return false;
-                    r.Remove(neighbourHandle);
+                    // remember banned
+                    m_bannedRegionCache.Add(neighbourRegion.RegionHandle, agentID);
+                    neighbourRegion = null;
                 }
             }
             else
             {
-                r = null;
+                // The destination region just doesn't exist
+                failureReason = "Cannot cross into non-existent region";
             }
 
-            GridRegion neighbourRegion = scene.GridService.GetRegionByPosition(scene.RegionInfo.ScopeID, (int)x, (int)y);
+            if (neighbourRegion == null)
+                m_log.DebugFormat("{0} GetDestination: region not found. Old region name={1} at <{2},{3}> of size <{4},{5}>. Old pos={6}",
+                    LogHeader, scene.RegionInfo.RegionName,
+                    scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY,
+                    scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY,
+                    pos);
+            else
+                m_log.DebugFormat("{0} GetDestination: new region={1} at <{2},{3}> of size <{4},{5}>, newpos=<{6},{7}>",
+                    LogHeader, neighbourRegion.RegionName,
+                    neighbourRegion.RegionLocX, neighbourRegion.RegionLocY, neighbourRegion.RegionSizeX, neighbourRegion.RegionSizeY,
+                    newpos.X, newpos.Y);
 
-            string reason;
-            string version;
-            if (!scene.SimulationService.QueryAccess(neighbourRegion, agent.ControllingClient.AgentId, newpos, out version, out reason))
-            {
-                agent.ControllingClient.SendAlertMessage("Cannot region cross into banned parcel");
-                if (r == null)
-                {
-                    r = new ExpiringCache<ulong, DateTime>();
-                    r.Add(neighbourHandle, DateTime.Now + TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
+            return neighbourRegion;
+        }
 
-                    m_bannedRegions.Add(agent.ControllingClient.AgentId, r, TimeSpan.FromSeconds(45));
-                }
-                else
-                {
-                    r.Add(neighbourHandle, DateTime.Now + TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
-                }
+        public bool Cross(ScenePresence agent, bool isFlying)
+        {
+            Vector3 newpos;
+            EntityTransferContext ctx = new EntityTransferContext();
+            string failureReason;
+
+            GridRegion neighbourRegion = GetDestination(agent.Scene, agent.UUID, agent.AbsolutePosition,
+                                                            ctx, out newpos, out failureReason);
+            if (neighbourRegion == null)
+            {
+                agent.ControllingClient.SendAlertMessage(failureReason);
                 return false;
             }
 
             agent.IsInTransit = true;
 
             CrossAgentToNewRegionDelegate d = CrossAgentToNewRegionAsync;
-            d.BeginInvoke(agent, newpos, neighbourx, neighboury, neighbourRegion, isFlying, version, CrossAgentToNewRegionCompleted, d);
+            d.BeginInvoke(agent, newpos, neighbourRegion, isFlying, ctx, CrossAgentToNewRegionCompleted, d);
+
+            Scene.EventManager.TriggerCrossAgentToNewRegion(agent, isFlying, neighbourRegion);
 
             return true;
         }
 
 
-        public delegate void InformClientToInitateTeleportToLocationDelegate(ScenePresence agent, uint regionX, uint regionY,
+        public delegate void InformClientToInitiateTeleportToLocationDelegate(ScenePresence agent, uint regionX, uint regionY,
                                                             Vector3 position,
                                                             Scene initiatingScene);
 
-        private void InformClientToInitateTeleportToLocation(ScenePresence agent, uint regionX, uint regionY, Vector3 position, Scene initiatingScene)
+        private void InformClientToInitiateTeleportToLocation(ScenePresence agent, uint regionX, uint regionY, Vector3 position, Scene initiatingScene)
         {
 
             // This assumes that we know what our neighbours are.
 
-            InformClientToInitateTeleportToLocationDelegate d = InformClientToInitiateTeleportToLocationAsync;
+            InformClientToInitiateTeleportToLocationDelegate d = InformClientToInitiateTeleportToLocationAsync;
             d.BeginInvoke(agent, regionX, regionY, position, initiatingScene,
                           InformClientToInitiateTeleportToLocationCompleted,
                           d);
@@ -1030,16 +1549,24 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             Scene initiatingScene)
         {
             Thread.Sleep(10000);
-            
+
+            m_log.DebugFormat(
+                "[ENTITY TRANSFER MODULE]: Auto-reteleporting {0} to correct megaregion location {1},{2},{3} from {4}", 
+                agent.Name, regionX, regionY, position, initiatingScene.Name);
+
+            agent.Scene.RequestTeleportLocation(
+                agent.ControllingClient, 
+                Util.RegionLocToHandle(regionX, regionY),
+                position, 
+                agent.Lookat, 
+                (uint)Constants.TeleportFlags.ViaLocation);
+
+            /*
             IMessageTransferModule im = initiatingScene.RequestModuleInterface<IMessageTransferModule>();
             if (im != null)
             {
                 UUID gotoLocation = Util.BuildFakeParcelID(
-                    Util.UIntsToLong(
-                                              (regionX *
-                                               (uint)Constants.RegionSize),
-                                              (regionY *
-                                               (uint)Constants.RegionSize)),
+                    Util.RegionLocToHandle(regionX, regionY),
                     (uint)(int)position.X,
                     (uint)(int)position.Y,
                     (uint)(int)position.Z);
@@ -1065,53 +1592,73 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 });
 
             }
+            */
         }
 
         private void InformClientToInitiateTeleportToLocationCompleted(IAsyncResult iar)
         {
-            InformClientToInitateTeleportToLocationDelegate icon =
-                (InformClientToInitateTeleportToLocationDelegate)iar.AsyncState;
+            InformClientToInitiateTeleportToLocationDelegate icon =
+                (InformClientToInitiateTeleportToLocationDelegate)iar.AsyncState;
             icon.EndInvoke(iar);
         }
 
-        public delegate ScenePresence CrossAgentToNewRegionDelegate(ScenePresence agent, Vector3 pos, uint neighbourx, uint neighboury, GridRegion neighbourRegion, bool isFlying, string version);
+        public bool CrossAgentToNewRegionPrep(ScenePresence agent, GridRegion neighbourRegion)
+        {
+            if (neighbourRegion == null)
+                return false;
+            
+            m_entityTransferStateMachine.SetInTransit(agent.UUID);
+
+            agent.RemoveFromPhysicalScene();
+
+            return true;
+        }
 
         /// <summary>
         /// This Closes child agents on neighbouring 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, GridRegion neighbourRegion,
-            bool isFlying, string version)
+        public ScenePresence CrossAgentToNewRegionAsync(
+                                ScenePresence agent, Vector3 pos, GridRegion neighbourRegion,
+                                bool isFlying, EntityTransferContext ctx)
         {
-            if (neighbourRegion == null)
-                return agent;
-
             try
             {
-                m_entityTransferStateMachine.SetInTransit(agent.UUID);
+                m_log.DebugFormat("{0}: CrossAgentToNewRegionAsync: new region={1} at <{2},{3}>. newpos={4}",
+                            LogHeader, neighbourRegion.RegionName, neighbourRegion.RegionLocX, neighbourRegion.RegionLocY, pos);
 
-                ulong neighbourHandle = Utils.UIntsToLong((uint)(neighbourx * Constants.RegionSize), (uint)(neighboury * Constants.RegionSize));
-    
-                m_log.DebugFormat(
-                    "[ENTITY TRANSFER MODULE]: Crossing agent {0} {1} to {2}-{3} running version {4}",
-                    agent.Firstname, agent.Lastname, neighbourx, neighboury, version);
-    
-                Scene m_scene = agent.Scene;
+                if (!CrossAgentToNewRegionPrep(agent, neighbourRegion))
+                {
+                    m_log.DebugFormat("{0}: CrossAgentToNewRegionAsync: prep failed. Resetting transfer state", LogHeader);
+                    m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
+                }
 
-                if (!agent.ValidateAttachments())
-                    m_log.DebugFormat(
-                        "[ENTITY TRANSFER MODULE]: Failed validation of all attachments for region crossing of {0} from {1} to {2}.  Continuing.",
-                        agent.Name, agent.Scene.RegionInfo.RegionName, neighbourRegion.RegionName);
+                if (!CrossAgentIntoNewRegionMain(agent, pos, neighbourRegion, isFlying, ctx))
+                {
+                    m_log.DebugFormat("{0}: CrossAgentToNewRegionAsync: cross main failed. Resetting transfer state", LogHeader);
+                    m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
+                }
 
-                pos = pos + agent.Velocity;
-                Vector3 vel2 = new Vector3(agent.Velocity.X, agent.Velocity.Y, 0);
+                CrossAgentToNewRegionPost(agent, pos, neighbourRegion, isFlying, ctx);
+            }
+            catch (Exception e)
+            {
+                m_log.Error(string.Format("{0}: CrossAgentToNewRegionAsync: failed with exception  ", LogHeader), e);
+            }
 
-                agent.RemoveFromPhysicalScene();
+            return agent;
+        }
 
+        public bool CrossAgentIntoNewRegionMain(ScenePresence agent, Vector3 pos, GridRegion neighbourRegion, bool isFlying, EntityTransferContext ctx)
+        {
+            try
+            {
                 AgentData cAgent = new AgentData(); 
                 agent.CopyTo(cAgent);
+                if (ctx.OutboundVersion < 0.5f)
+                    cAgent.Appearance.PackLegacyWearables = true;
                 cAgent.Position = pos;
+
                 if (isFlying)
                     cAgent.ControlFlags |= (uint)AgentManager.ControlFlags.AGENT_CONTROL_FLY;
 
@@ -1121,102 +1668,121 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 // Beyond this point, extra cleanup is needed beyond removing transit state
                 m_entityTransferStateMachine.UpdateInTransit(agent.UUID, AgentTransferState.Transferring);
 
-                if (!m_scene.SimulationService.UpdateAgent(neighbourRegion, cAgent))
+                if (!agent.Scene.SimulationService.UpdateAgent(neighbourRegion, cAgent))
                 {
                     // region doesn't take it
                     m_entityTransferStateMachine.UpdateInTransit(agent.UUID, AgentTransferState.CleaningUp);
 
+                    m_log.WarnFormat(
+                        "[ENTITY TRANSFER MODULE]: Region {0} would not accept update for agent {1} on cross attempt.  Returning to original region.", 
+                        neighbourRegion.RegionName, agent.Name);
+
                     ReInstantiateScripts(agent);
                     agent.AddToPhysicalScene(isFlying);
-                    m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
 
-                    return agent;
+                    return false;
                 }
 
-                //AgentCircuitData circuitdata = m_controllingClient.RequestClientInfo();
-                agent.ControllingClient.RequestClientInfo();
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat(
+                    "[ENTITY TRANSFER MODULE]: Problem crossing user {0} to new region {1} from {2}.  Exception {3}{4}",
+                    agent.Name, neighbourRegion.RegionName, agent.Scene.RegionInfo.RegionName, e.Message, e.StackTrace);
+
+                // TODO: Might be worth attempting other restoration here such as reinstantiation of scripts, etc.
+                return false;
+            }
 
-                //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;
-                }
-                // No turning back
-                agent.IsChildAgent = true;
+            return true;
+        }
 
-                string capsPath = neighbourRegion.ServerURI + CapsUtil.GetCapsSeedPath(agentcaps);
+        public void CrossAgentToNewRegionPost(ScenePresence agent, Vector3 pos, GridRegion neighbourRegion,
+            bool isFlying, EntityTransferContext ctx)
+        {
+            agent.ControllingClient.RequestClientInfo();
 
-                m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} to client {1}", capsPath, agent.UUID);
+            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;
+            }
 
-                if (m_eqModule != null)
-                {
-                    m_eqModule.CrossRegion(
-                        neighbourHandle, pos, vel2 /* agent.Velocity */, neighbourRegion.ExternalEndPoint,
-                        capsPath, agent.UUID, agent.ControllingClient.SessionId);
-                }
-                else
-                {
-                    agent.ControllingClient.CrossRegion(neighbourHandle, pos, agent.Velocity, neighbourRegion.ExternalEndPoint,
-                                                capsPath);
-                }
+            // No turning back
+            agent.IsChildAgent = true;
+
+            string capsPath = neighbourRegion.ServerURI + CapsUtil.GetCapsSeedPath(agentcaps);
 
-                // SUCCESS!
-                m_entityTransferStateMachine.UpdateInTransit(agent.UUID, AgentTransferState.ReceivedAtDestination);
+            m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} to client {1}", capsPath, agent.UUID);
 
-                // Unlike a teleport, here we do not wait for the destination region to confirm the receipt.
-                m_entityTransferStateMachine.UpdateInTransit(agent.UUID, AgentTransferState.CleaningUp);
+            Vector3 vel2 = new Vector3(agent.Velocity.X, agent.Velocity.Y, 0);
 
-                agent.MakeChildAgent();
+            if (m_eqModule != null)
+            {
+                m_eqModule.CrossRegion(
+                    neighbourRegion.RegionHandle, pos + agent.Velocity, vel2 /* agent.Velocity */,
+                    neighbourRegion.ExternalEndPoint,
+                    capsPath, agent.UUID, agent.ControllingClient.SessionId,
+                    neighbourRegion.RegionSizeX, neighbourRegion.RegionSizeY);
+            }
+            else
+            {
+                m_log.ErrorFormat("{0} Using old CrossRegion packet. Varregion will not work!!", LogHeader);
+                agent.ControllingClient.CrossRegion(neighbourRegion.RegionHandle, pos + agent.Velocity, agent.Velocity, neighbourRegion.ExternalEndPoint,
+                                            capsPath);
+            }
 
-                // FIXME: Possibly this should occur lower down after other commands to close other agents,
-                // but not sure yet what the side effects would be.
-                m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
+            // SUCCESS!
+            m_entityTransferStateMachine.UpdateInTransit(agent.UUID, AgentTransferState.ReceivedAtDestination);
 
-                // now we have a child agent in this region. Request all interesting data about other (root) agents
-                agent.SendOtherAgentsAvatarDataToMe();
-                agent.SendOtherAgentsAppearanceToMe();
+            // Unlike a teleport, here we do not wait for the destination region to confirm the receipt.
+            m_entityTransferStateMachine.UpdateInTransit(agent.UUID, AgentTransferState.CleaningUp);
 
-                // Backwards compatibility. Best effort
-                if (version == "Unknown" || version == string.Empty)
-                {
-                    m_log.DebugFormat("[ENTITY TRANSFER MODULE]: neighbor with old version, passing attachments one by one...");
-                    Thread.Sleep(3000); // wait a little now that we're not waiting for the callback
-                    CrossAttachmentsIntoNewRegion(neighbourRegion, agent, true);
-                }
+            agent.MakeChildAgent();
 
-                // Next, let's close the child agent connections that are too far away.
-                agent.CloseChildAgents(neighbourx, neighboury);
+            // FIXME: Possibly this should occur lower down after other commands to close other agents,
+            // but not sure yet what the side effects would be.
+            m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
 
-                AgentHasMovedAway(agent, false);
+            // now we have a child agent in this region. Request all interesting data about other (root) agents
+            agent.SendOtherAgentsAvatarDataToClient();
+            agent.SendOtherAgentsAppearanceToClient();
 
-//                // 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();
-            }
-            catch (Exception e)
+            // TODO: Check since what version this wasn't needed anymore. May be as old as 0.6
+/*
+            // Backwards compatibility. Best effort
+            if (version == 0f)
             {
-                m_log.ErrorFormat(
-                    "[ENTITY TRANSFER MODULE]: Problem crossing user {0} to new region {1} from {2}.  Exception {3}{4}",
-                    agent.Name, neighbourRegion.RegionName, agent.Scene.RegionInfo.RegionName, e.Message, e.StackTrace);
-
-                // TODO: Might be worth attempting other restoration here such as reinstantiation of scripts, etc.
+                m_log.DebugFormat("[ENTITY TRANSFER MODULE]: neighbor with old version, passing attachments one by one...");
+                Thread.Sleep(3000); // wait a little now that we're not waiting for the callback
+                CrossAttachmentsIntoNewRegion(neighbourRegion, agent, true);
             }
+*/
+            // Next, let's close the child agent connections that are too far away.
+            uint neighbourx;
+            uint neighboury;
+            Util.RegionHandleToRegionLoc(neighbourRegion.RegionHandle, out neighbourx, out neighboury);
 
-            return agent;
+            agent.CloseChildAgents(neighbourx, neighboury);
+
+            AgentHasMovedAway(agent, false);
+
+            // 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;
         }
          
         private void CrossAgentToNewRegionCompleted(IAsyncResult iar)
@@ -1256,7 +1822,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             agent.InventoryFolder = UUID.Zero;
             agent.startpos = new Vector3(128, 128, 70);
             agent.child = true;
-            agent.Appearance = sp.Appearance;
+            agent.Appearance = new AvatarAppearance();
+            agent.Appearance.PackLegacyWearables = true;
             agent.CapsPath = CapsUtil.GetRandomCapsObjectPath();
 
             agent.ChildrenCapSeeds = new Dictionary<ulong, string>(sp.Scene.CapsModule.GetChildrenSeeds(sp.UUID));
@@ -1270,7 +1837,15 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             //foreach (ulong h in agent.ChildrenCapSeeds.Keys)
             //    m_log.DebugFormat("[XXX] --> {0}", h);
             //m_log.DebugFormat("[XXX] Adding {0}", region.RegionHandle);
-            agent.ChildrenCapSeeds.Add(region.RegionHandle, agent.CapsPath);
+            if (agent.ChildrenCapSeeds.ContainsKey(region.RegionHandle))
+            {
+                m_log.WarnFormat(
+                    "[ENTITY TRANSFER]: Overwriting caps seed {0} with {1} for region {2} (handle {3}) for {4} in {5}", 
+                    agent.ChildrenCapSeeds[region.RegionHandle], agent.CapsPath, 
+                    region.RegionName, region.RegionHandle, sp.Name, Scene.Name);
+            }
+
+            agent.ChildrenCapSeeds[region.RegionHandle] = agent.CapsPath;
 
             if (sp.Scene.CapsModule != null)
             {
@@ -1287,10 +1862,14 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 agent.Id0 = currentAgentCircuit.Id0;
             }
 
-            InformClientOfNeighbourDelegate d = InformClientOfNeighbourAsync;
-            d.BeginInvoke(sp, agent, region, region.ExternalEndPoint, true,
+            IPEndPoint external = region.ExternalEndPoint;
+            if (external != null)
+            {
+                InformClientOfNeighbourDelegate d = InformClientOfNeighbourAsync;
+                d.BeginInvoke(sp, agent, region, external, true,
                           InformClientOfNeighbourCompleted,
                           d);
+            }
         }
         #endregion
 
@@ -1310,7 +1889,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             if (m_regionInfo != null)
             {
-                neighbours = RequestNeighbours(sp, m_regionInfo.RegionLocX, m_regionInfo.RegionLocY);
+                neighbours = GetNeighbours(sp, m_regionInfo.RegionLocX, m_regionInfo.RegionLocY);
             }
             else
             {
@@ -1336,10 +1915,10 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             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);
+//            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);
@@ -1347,8 +1926,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             /// 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));
+                seeds = new Dictionary<ulong, string>(sp.Scene.CapsModule.GetChildrenSeeds(sp.UUID));
             else
                 seeds = new Dictionary<ulong, string>();
 
@@ -1368,7 +1946,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     agent.InventoryFolder = UUID.Zero;
                     agent.startpos = sp.AbsolutePosition + CalculateOffset(sp, neighbour);
                     agent.child = true;
-                    agent.Appearance = sp.Appearance;
+                    agent.Appearance = new AvatarAppearance();
+                    agent.Appearance.PackLegacyWearables = true;
                     if (currentAgentCircuit != null)
                     {
                         agent.ServiceURLs = currentAgentCircuit.ServiceURLs;
@@ -1418,6 +1997,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     newAgent = true;
                 else
                     newAgent = false;
+//                    continue;
 
                 if (neighbour.RegionHandle != sp.Scene.RegionInfo.RegionHandle)
                 {
@@ -1464,15 +2044,195 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
         }
 
+        // Computes the difference between two region bases.
+        // Returns a vector of world coordinates (meters) from base of first region to the second.
+        // The first region is the home region of the passed scene presence.
         Vector3 CalculateOffset(ScenePresence sp, GridRegion neighbour)
         {
-            int rRegionX = (int)sp.Scene.RegionInfo.RegionLocX;
-            int rRegionY = (int)sp.Scene.RegionInfo.RegionLocY;
+            /*
+            int rRegionX = (int)sp.Scene.RegionInfo.LegacyRegionLocX;
+            int rRegionY = (int)sp.Scene.RegionInfo.LegacyRegionLocY;
             int tRegionX = neighbour.RegionLocX / (int)Constants.RegionSize;
             int tRegionY = neighbour.RegionLocY / (int)Constants.RegionSize;
             int shiftx = (rRegionX - tRegionX) * (int)Constants.RegionSize;
             int shifty = (rRegionY - tRegionY) * (int)Constants.RegionSize;
             return new Vector3(shiftx, shifty, 0f);
+             */
+            return new Vector3( sp.Scene.RegionInfo.WorldLocX - neighbour.RegionLocX,
+                                sp.Scene.RegionInfo.WorldLocY - neighbour.RegionLocY,
+                                0f);
+        }
+
+        public GridRegion GetRegionContainingWorldLocation(IGridService pGridService, UUID pScopeID, double px, double py)
+        {
+            // Since we don't know how big the regions could be, we have to search a very large area
+            //    to find possible regions.
+            return GetRegionContainingWorldLocation(pGridService, pScopeID, px, py, Constants.MaximumRegionSize);
+        }
+
+        #region NotFoundLocationCache class
+        // A collection of not found locations to make future lookups 'not found' lookups quick.
+        // A simple expiring cache that keeps not found locations for some number of seconds.
+        // A 'not found' location is presumed to be anywhere in the minimum sized region that
+        //    contains that point. A conservitive estimate.
+        private class NotFoundLocationCache
+        {
+            private struct NotFoundLocation
+            {
+                public double minX, maxX, minY, maxY;
+                public DateTime expireTime;
+            }
+            private List<NotFoundLocation> m_notFoundLocations = new List<NotFoundLocation>();
+            public NotFoundLocationCache()
+            {
+            }
+            // Add an area to the list of 'not found' places. The area is the snapped region
+            //    area around the added point.
+            public void Add(double pX, double pY)
+            {
+                lock (m_notFoundLocations)
+                {
+                    if (!LockedContains(pX, pY))
+                    {
+                        NotFoundLocation nfl = new NotFoundLocation();
+                        // A not found location is not found for at least a whole region sized area
+                        nfl.minX = pX - (pX % (double)Constants.RegionSize);
+                        nfl.minY = pY - (pY % (double)Constants.RegionSize);
+                        nfl.maxX = nfl.minX + (double)Constants.RegionSize;
+                        nfl.maxY = nfl.minY + (double)Constants.RegionSize;
+                        nfl.expireTime = DateTime.Now + TimeSpan.FromSeconds(30);
+                        m_notFoundLocations.Add(nfl);
+                    }
+                }
+                
+            }
+            // Test to see of this point is in any of the 'not found' areas.
+            // Return 'true' if the point is found inside the 'not found' areas.
+            public bool Contains(double pX, double pY)
+            {
+                bool ret = false;
+                lock (m_notFoundLocations)
+                    ret = LockedContains(pX, pY);
+                return ret;
+            }
+            private bool LockedContains(double pX, double pY)
+            {
+                bool ret = false;
+                this.DoExpiration();
+                foreach (NotFoundLocation nfl in m_notFoundLocations)
+                {
+                    if (pX >= nfl.minX && pX < nfl.maxX && pY >= nfl.minY && pY < nfl.maxY)
+                    {
+                        ret = true;
+                        break;
+                    }
+                }
+                return ret;
+            }
+            private void DoExpiration()
+            {
+                List<NotFoundLocation> m_toRemove = null;
+                DateTime now = DateTime.Now;
+                foreach (NotFoundLocation nfl in m_notFoundLocations)
+                {
+                    if (nfl.expireTime < now)
+                    {
+                        if (m_toRemove == null)
+                            m_toRemove = new List<NotFoundLocation>();
+                        m_toRemove.Add(nfl);
+                    }
+                }
+                if (m_toRemove != null)
+                {
+                    foreach (NotFoundLocation nfl in m_toRemove)
+                        m_notFoundLocations.Remove(nfl);
+                    m_toRemove.Clear();
+                }
+            }
+        }
+        #endregion // NotFoundLocationCache class
+        private NotFoundLocationCache m_notFoundLocationCache = new NotFoundLocationCache();
+
+        // Given a world position (fractional meter coordinate), get the GridRegion info for
+        //   the region containing that point.
+        // Someday this should be a method on GridService.
+        // 'pSizeHint' is the size of the source region but since the destination point can be anywhere
+        //     the size of the target region is unknown thus the search area might have to be very large.
+        // Return 'null' if no such region exists.
+        public GridRegion GetRegionContainingWorldLocation(IGridService pGridService, UUID pScopeID,
+                            double px, double py, uint pSizeHint)
+        {
+            m_log.DebugFormat("{0} GetRegionContainingWorldLocation: query, loc=<{1},{2}>", LogHeader, px, py);
+            GridRegion ret = null;
+            const double fudge = 2.0;
+
+            // One problem with this routine is negative results. That is, this can be called lots of times
+            //   for regions that don't exist. m_notFoundLocationCache remembers 'not found' results so they
+            //   will be quick 'not found's next time.
+            // NotFoundLocationCache is an expiring cache so it will eventually forget about 'not found' and
+            //   thus re-ask the GridService about the location.
+            if (m_notFoundLocationCache.Contains(px, py))
+            {
+                m_log.DebugFormat("{0} GetRegionContainingWorldLocation: Not found via cache. loc=<{1},{2}>", LogHeader, px, py);
+                return null;
+            }
+
+            // As an optimization, since most regions will be legacy sized regions (256x256), first try to get
+            //   the region at the appropriate legacy region location.
+            uint possibleX = (uint)Math.Floor(px);
+            possibleX -= possibleX % Constants.RegionSize;
+            uint possibleY = (uint)Math.Floor(py);
+            possibleY -= possibleY % Constants.RegionSize;
+            ret = pGridService.GetRegionByPosition(pScopeID, (int)possibleX, (int)possibleY);
+            if (ret != null)
+            {
+                m_log.DebugFormat("{0} GetRegionContainingWorldLocation: Found region using legacy size. rloc=<{1},{2}>. Rname={3}",
+                                    LogHeader, possibleX, possibleY, ret.RegionName);
+            }
+
+            if (ret == null)
+            {
+                // If the simple lookup failed, search the larger area for a region that contains this point
+                double range = (double)pSizeHint + fudge;
+                while (ret == null && range <= (Constants.MaximumRegionSize + Constants.RegionSize))
+                {
+                    // Get from the grid service a list of regions that might contain this point.
+                    // The region origin will be in the zero direction so only subtract the range.
+                    List<GridRegion> possibleRegions = pGridService.GetRegionRange(pScopeID,
+                                        (int)(px - range), (int)(px),
+                                        (int)(py - range), (int)(py));
+                    m_log.DebugFormat("{0} GetRegionContainingWorldLocation: possibleRegions cnt={1}, range={2}",
+                                        LogHeader, possibleRegions.Count, range);
+                    if (possibleRegions != null && possibleRegions.Count > 0)
+                    {
+                        // If we found some regions, check to see if the point is within
+                        foreach (GridRegion gr in possibleRegions)
+                        {
+                            m_log.DebugFormat("{0} GetRegionContainingWorldLocation: possibleRegion nm={1}, regionLoc=<{2},{3}>, regionSize=<{4},{5}>",
+                                                LogHeader, gr.RegionName, gr.RegionLocX, gr.RegionLocY, gr.RegionSizeX, gr.RegionSizeY);
+                            if (px >= (double)gr.RegionLocX && px < (double)(gr.RegionLocX + gr.RegionSizeX)
+                                && py >= (double)gr.RegionLocY && py < (double)(gr.RegionLocY + gr.RegionSizeY))
+                            {
+                                // Found a region that contains the point
+                                ret = gr;
+                                m_log.DebugFormat("{0} GetRegionContainingWorldLocation: found. RegionName={1}", LogHeader, ret.RegionName);
+                                break;
+                            }
+                        }
+                    }
+                    // Larger search area for next time around if not found
+                    range *= 2;
+                }
+            }
+
+            if (ret == null)
+            {
+                // remember this location was not found so we can quickly not find it next time
+                m_notFoundLocationCache.Add(px, py);
+                m_log.DebugFormat("{0} GetRegionContainingWorldLocation: Not found. Remembering loc=<{1},{2}>", LogHeader, px, py);
+            }
+
+            return ret;
         }
 
         private void InformClientOfNeighbourCompleted(IAsyncResult iar)
@@ -1500,7 +2260,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             Thread.Sleep(500);
 
             Scene scene = sp.Scene;
-
+            
             m_log.DebugFormat(
                 "[ENTITY TRANSFER MODULE]: Informing {0} {1} about neighbour {2} {3} at ({4},{5})",
                 sp.Name, sp.UUID, reg.RegionName, endPoint, reg.RegionCoordX, reg.RegionCoordY);
@@ -1509,7 +2269,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             string reason = String.Empty;
 
-            bool regionAccepted = scene.SimulationService.CreateAgent(reg, a, (uint)TeleportFlags.Default, out reason);
+            bool regionAccepted = scene.SimulationService.CreateAgent(null, reg, a, (uint)TeleportFlags.Default, out reason);
 
             if (regionAccepted && newAgent)
             {
@@ -1523,12 +2283,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     }
                     #endregion
 
-                    m_log.DebugFormat("[ENTITY TRANSFER MODULE]: {0} is sending {1} EnableSimulator for neighbour region {2} @ {3} " +
-                        "and EstablishAgentCommunication with seed cap {4}",
-                        scene.RegionInfo.RegionName, sp.Name, reg.RegionName, reg.RegionHandle, capsPath);
+                    m_log.DebugFormat("{0} {1} is sending {2} EnableSimulator for neighbour region {3}(loc=<{4},{5}>,siz=<{6},{7}>) " +
+                        "and EstablishAgentCommunication with seed cap {8}", LogHeader,
+                        scene.RegionInfo.RegionName, sp.Name,
+                        reg.RegionName, reg.RegionLocX, reg.RegionLocY, reg.RegionSizeX, reg.RegionSizeY , capsPath);
 
-                    m_eqModule.EnableSimulator(reg.RegionHandle, endPoint, sp.UUID);
-                    m_eqModule.EstablishAgentCommunication(sp.UUID, endPoint, capsPath);
+                    m_eqModule.EnableSimulator(reg.RegionHandle, endPoint, sp.UUID, reg.RegionSizeX, reg.RegionSizeY);
+                    m_eqModule.EstablishAgentCommunication(sp.UUID, endPoint, capsPath, reg.RegionHandle, reg.RegionSizeX, reg.RegionSizeY);
                 }
                 else
                 {
@@ -1546,68 +2307,86 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         }
 
         /// <summary>
-        /// Return the list of regions that are considered to be neighbours to the given scene.
+        /// Gets the range considered in view of this megaregion (assuming this is a megaregion).
+        /// </summary>
+        /// <remarks>Expressed in 256m units</remarks>
+        /// <param name='swCorner'></param>
+        /// <param name='neCorner'></param>
+        private void GetMegaregionViewRange(out Vector2 swCorner, out Vector2 neCorner)
+        {
+            Vector2 extent = Vector2.Zero;
+
+            if (m_regionCombinerModule != null)
+            {
+                Vector2 megaRegionSize = m_regionCombinerModule.GetSizeOfMegaregion(Scene.RegionInfo.RegionID);
+                extent.X = (float)Util.WorldToRegionLoc((uint)megaRegionSize.X);
+                extent.Y = (float)Util.WorldToRegionLoc((uint)megaRegionSize.Y);
+            }
+
+            swCorner.X = Scene.RegionInfo.RegionLocX - 1;
+            swCorner.Y = Scene.RegionInfo.RegionLocY - 1;
+            neCorner.X = Scene.RegionInfo.RegionLocX + extent.X;
+            neCorner.Y = Scene.RegionInfo.RegionLocY + extent.Y;
+        }
+
+        /// <summary>
+        /// Return the list of online regions that are considered to be neighbours to the given scene.
         /// </summary>
-        /// <param name="pScene"></param>
+        /// <param name="avatar"></param>
         /// <param name="pRegionLocX"></param>
         /// <param name="pRegionLocY"></param>
         /// <returns></returns>        
-        protected List<GridRegion> RequestNeighbours(ScenePresence avatar, uint pRegionLocX, uint pRegionLocY)
+        protected List<GridRegion> GetNeighbours(ScenePresence avatar, uint pRegionLocX, uint pRegionLocY)
         {
             Scene pScene = avatar.Scene;
             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();
+            List<GridRegion> neighbours;
 
             // Leaving this as a "megaregions" computation vs "non-megaregions" computation; it isn't
             // clear what should be done with a "far view" given that megaregions already extended the
             // view to include everything in the megaregion
-            if (northBorders.Length <= 1 && southBorders.Length <= 1 && eastBorders.Length <= 1 && westBorders.Length <= 1)
+            if (m_regionCombinerModule == null || !m_regionCombinerModule.IsRootForMegaregion(Scene.RegionInfo.RegionID))
             {
-                int dd = avatar.DrawDistance < Constants.RegionSize ? (int)Constants.RegionSize : (int)avatar.DrawDistance;
-
-                int startX = (int)pRegionLocX * (int)Constants.RegionSize - dd + (int)(Constants.RegionSize/2);
-                int startY = (int)pRegionLocY * (int)Constants.RegionSize - dd + (int)(Constants.RegionSize/2);
+                // The area to check is as big as the current region.
+                // We presume all adjacent regions are the same size as this region.
+                uint dd = Math.Max((uint)avatar.Scene.DefaultDrawDistance, 
+                                Math.Max(Scene.RegionInfo.RegionSizeX, Scene.RegionInfo.RegionSizeY));
 
-                int endX = (int)pRegionLocX * (int)Constants.RegionSize + dd + (int)(Constants.RegionSize/2);
-                int endY = (int)pRegionLocY * (int)Constants.RegionSize + dd + (int)(Constants.RegionSize/2);
+                uint startX = Util.RegionToWorldLoc(pRegionLocX) - dd + Constants.RegionSize/2;
+                uint startY = Util.RegionToWorldLoc(pRegionLocY) - dd + Constants.RegionSize/2;
 
-                List<GridRegion> neighbours =
-                    avatar.Scene.GridService.GetRegionRange(m_regionInfo.ScopeID, startX, endX, startY, endY);
+                uint endX = Util.RegionToWorldLoc(pRegionLocX) + dd + Constants.RegionSize/2;
+                uint endY = Util.RegionToWorldLoc(pRegionLocY) + dd + Constants.RegionSize/2;
 
-                neighbours.RemoveAll(delegate(GridRegion r) { return r.RegionID == m_regionInfo.RegionID; });
-                return neighbours;
+                neighbours 
+                    = avatar.Scene.GridService.GetRegionRange(
+                        m_regionInfo.ScopeID, (int)startX, (int)endX, (int)startY, (int)endY);
             }
             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;
-                }
+                Vector2 swCorner, neCorner;
+                GetMegaregionViewRange(out swCorner, out neCorner);
 
-                // 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;
+                neighbours 
+                    = pScene.GridService.GetRegionRange(
+                        m_regionInfo.ScopeID, 
+                        (int)Util.RegionToWorldLoc((uint)swCorner.X), (int)Util.RegionToWorldLoc((uint)neCorner.X),
+                        (int)Util.RegionToWorldLoc((uint)swCorner.Y), (int)Util.RegionToWorldLoc((uint)neCorner.Y));
+            }
 
-                int endX = ((int)pRegionLocX + (int)extent.X) * (int)Constants.RegionSize;
-                int endY = ((int)pRegionLocY + (int)extent.Y) * (int)Constants.RegionSize;
+//            neighbours.ForEach(
+//                n => 
+//                    m_log.DebugFormat(
+//                        "[ENTITY TRANSFER MODULE]: Region flags for {0} as seen by {1} are {2}", 
+//                        n.RegionName, Scene.Name, n.RegionFlags != null ? n.RegionFlags.ToString() : "not present"));
 
-                List<GridRegion> neighbours = pScene.GridService.GetRegionRange(m_regionInfo.ScopeID, startX, endX, startY, endY);
-                neighbours.RemoveAll(delegate(GridRegion r) { return r.RegionID == m_regionInfo.RegionID; });
+            // The r.RegionFlags == null check only needs to be made for simulators before 2015-01-14 (pre 0.8.1).
+            neighbours.RemoveAll(
+                r => 
+                    r.RegionID == m_regionInfo.RegionID 
+                        || (r.RegionFlags != null && (r.RegionFlags & OpenSim.Framework.RegionFlags.RegionOnline) == 0));
 
-                return neighbours;
-            }
+            return neighbours;
         }
 
         private List<ulong> NewNeighbours(List<ulong> currentNeighbours, List<ulong> previousNeighbours)
@@ -1665,10 +2444,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         /// 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
+        /// Using the objects new world location, ask the grid service for a the new region and adjust the prim
+        /// position to be relative to 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>
+        /// <param name="attemptedPosition">the attempted out of region position of the scene object. This position is
+        /// relative to the region the object currently is in.</param>
+        /// <param name="silent">if 'true', the deletion of the client from the region is not broadcast to the clients</param>
         public void Cross(SceneObjectGroup grp, Vector3 attemptedPosition, bool silent)
         {
             if (grp == null)
@@ -1694,204 +2476,49 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 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));
-
+            // Remember the old group position in case the region lookup fails so position can be restored.
+            Vector3 oldGroupPosition = grp.RootPart.GroupPosition;
 
-                    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)
+            // Compute the absolute position of the object.
+            double objectWorldLocX = (double)scene.RegionInfo.WorldLocX + attemptedPosition.X;
+            double objectWorldLocY = (double)scene.RegionInfo.WorldLocY + attemptedPosition.Y;
 
-                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));
+            // Ask the grid service for the region that contains the passed address
+            GridRegion destination = GetRegionContainingWorldLocation(scene.GridService, scene.RegionInfo.ScopeID,
+                                objectWorldLocX, objectWorldLocY);
 
-                newRegionHandle
-                    = Util.UIntsToLong((uint)(thisx * Constants.RegionSize), (uint)((thisy - changeY) * Constants.RegionSize));
-                // y - 1
-            }
-            else if (scene.TestBorderCross(attemptedPosition + NorthCross, Cardinals.N))
+            Vector3 pos = Vector3.Zero;
+            if (destination != null)
             {
-
-                pos.Y = ((pos.Y - Constants.RegionSize));
-                newRegionHandle
-                    = Util.UIntsToLong((uint)(thisx * Constants.RegionSize), (uint)((thisy + changeY) * Constants.RegionSize));
-                // y + 1
+                // Adjust the object's relative position from the old region (attemptedPosition)
+                //    to be relative to the new region (pos).
+                pos = new Vector3(  (float)(objectWorldLocX - (double)destination.RegionLocX),
+                                    (float)(objectWorldLocY - (double)destination.RegionLocY),
+                                    attemptedPosition.Z);
             }
 
-            // Offset the positions for the new region across the border
-            Vector3 oldGroupPosition = grp.RootPart.GroupPosition;
-
-            // 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(scene.RegionInfo.ScopeID, (int)x, (int)y);
-
             if (destination == null || !CrossPrimGroupIntoNewRegion(destination, pos, grp, silent))
             {
-                m_log.InfoFormat("[ENTITY TRANSFER MODULE] cross region transfer failed for object {0}",grp.UUID);
+                m_log.InfoFormat("[ENTITY TRANSFER MODULE] cross region transfer failed for object {0}", grp.UUID);
 
                 // We are going to move the object back to the old position so long as the old position
                 // is in the region
-                oldGroupPosition.X = Util.Clamp<float>(oldGroupPosition.X,1.0f,(float)Constants.RegionSize-1);
-                oldGroupPosition.Y = Util.Clamp<float>(oldGroupPosition.Y,1.0f,(float)Constants.RegionSize-1);
-                oldGroupPosition.Z = Util.Clamp<float>(oldGroupPosition.Z,1.0f,4096.0f);
+                oldGroupPosition.X = Util.Clamp<float>(oldGroupPosition.X, 1.0f, (float)(scene.RegionInfo.RegionSizeX - 1));
+                oldGroupPosition.Y = Util.Clamp<float>(oldGroupPosition.Y, 1.0f, (float)(scene.RegionInfo.RegionSizeY - 1));
+                oldGroupPosition.Z = Util.Clamp<float>(oldGroupPosition.Z, 1.0f, Constants.RegionHeight);
 
-                grp.RootPart.GroupPosition = oldGroupPosition;
+                grp.AbsolutePosition = oldGroupPosition;
+                grp.Velocity = Vector3.Zero;
+                if (grp.RootPart.PhysActor != null)
+                    grp.RootPart.PhysActor.CrossingFailure();
 
-                // Need to turn off the physics flags, otherwise the object will continue to attempt to
-                // move out of the region creating an infinite loop of failed attempts to cross
-                grp.UpdatePrimFlags(grp.RootPart.LocalId,false,grp.IsTemporary,grp.IsPhantom,false);
+                if (grp.RootPart.KeyframeMotion != null)
+                    grp.RootPart.KeyframeMotion.CrossingFailure();
 
                 grp.ScheduleGroupForFullUpdate();
             }
         }
 
-
         /// <summary>
         /// Move the given scene object into a new region
         /// </summary>
@@ -1942,17 +2569,30 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                             grp, e);
                     }
                 }
+/*
+ * done on caller ( not in attachments crossing for now)
                 else
                 {
+
                     if (!grp.IsDeleted)
                     {
                         PhysicsActor pa = grp.RootPart.PhysActor;
                         if (pa != null)
+                        {
                             pa.CrossingFailure();
+                            if (grp.RootPart.KeyframeMotion != null)
+                            {
+                                // moved to KeyframeMotion.CrossingFailure
+//                                grp.RootPart.Velocity = Vector3.Zero;
+                                grp.RootPart.KeyframeMotion.CrossingFailure();
+//                                grp.SendGroupRootTerseUpdate();
+                            }
+                        }
                     }
 
                     m_log.ErrorFormat("[ENTITY TRANSFER MODULE]: Prim crossing failed for {0}", grp);
                 }
+ */
             }
             else
             {
@@ -2007,7 +2647,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         public bool IsInTransit(UUID id)
         {
-            return m_entityTransferStateMachine.IsInTransit(id);
+            return m_entityTransferStateMachine.GetAgentTransferState(id) != null;
         }
 
         protected void ReInstantiateScripts(ScenePresence sp)
@@ -2036,5 +2676,69 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         }
         #endregion
 
+        public virtual bool HandleIncomingSceneObject(SceneObjectGroup so, Vector3 newPosition)
+        {
+            // If the user is banned, we won't let any of their objects
+            // enter. Period.
+            //
+            if (Scene.RegionInfo.EstateSettings.IsBanned(so.OwnerID))
+            {
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Denied prim crossing of {0} {1} into {2} for banned avatar {3}", 
+                    so.Name, so.UUID, Scene.Name, so.OwnerID);
+
+                return false;
+            }
+
+            if (newPosition != Vector3.Zero)
+                so.RootPart.GroupPosition = newPosition;
+
+            if (!Scene.AddSceneObject(so))
+            {
+                m_log.DebugFormat(
+                    "[ENTITY TRANSFER MODULE]: Problem adding scene object {0} {1} into {2} ", 
+                    so.Name, so.UUID, Scene.Name);
+
+                return false;
+            }
+
+            if (!so.IsAttachment)
+            {
+                // FIXME: It would be better to never add the scene object at all rather than add it and then delete
+                // it
+                if (!Scene.Permissions.CanObjectEntry(so.UUID, true, so.AbsolutePosition))
+                {
+                    // Deny non attachments based on parcel settings
+                    //
+                    m_log.Info("[ENTITY TRANSFER MODULE]: Denied prim crossing because of parcel settings");
+
+                    Scene.DeleteSceneObject(so, false);
+
+                    return false;
+                }
+
+                // For attachments, we need to wait until the agent is root
+                // before we restart the scripts, or else some functions won't work.
+                so.RootPart.ParentGroup.CreateScriptInstances(
+                    0, false, Scene.DefaultScriptEngine, GetStateSource(so));
+
+                so.ResumeScripts();
+
+                if (so.RootPart.KeyframeMotion != null)
+                    so.RootPart.KeyframeMotion.UpdateSceneObject(so);
+            }
+
+            return true;
+        }
+
+        private int GetStateSource(SceneObjectGroup sog)
+        {
+            ScenePresence sp = Scene.GetScenePresence(sog.OwnerID);
+
+            if (sp != null)
+                return sp.GetStateSource();
+
+            return 2; // StateSource.PrimCrossing
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs
index d0cab49..a3109e0 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs
@@ -38,7 +38,7 @@ using OpenSim.Framework.Capabilities;
 using OpenSim.Framework.Client;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
-using OpenSim.Region.Physics.Manager;
+using OpenSim.Region.PhysicsModules.SharedBase;
 using OpenSim.Services.Interfaces;
 using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 
@@ -51,10 +51,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
     /// This is a state machine.
     ///
     /// [Entry]               => Preparing
-    /// Preparing             => { Transferring || CleaningUp || [Exit] }
-    /// Transferring          => { ReceivedAtDestination || CleaningUp }
-    /// ReceivedAtDestination => CleaningUp
+    /// Preparing             => { Transferring || Cancelling || CleaningUp || Aborting || [Exit] }
+    /// Transferring          => { ReceivedAtDestination || Cancelling || CleaningUp || Aborting }
+    /// Cancelling            => CleaningUp || Aborting
+    /// ReceivedAtDestination => CleaningUp || Aborting
     /// CleaningUp            => [Exit]
+    /// Aborting              => [Exit]
     ///
     /// In other words, agents normally travel throwing Preparing => Transferring => ReceivedAtDestination => CleaningUp
     /// However, any state can transition to CleaningUp if the teleport has failed.
@@ -64,7 +66,9 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         Preparing,              // The agent is being prepared for transfer
         Transferring,           // The agent is in the process of being transferred to a destination
         ReceivedAtDestination,  // The destination has notified us that the agent has been successfully received
-        CleaningUp              // The agent is being changed to child/removed after a transfer
+        CleaningUp,             // The agent is being changed to child/removed after a transfer
+        Cancelling,             // The user has cancelled the teleport but we have yet to act upon this.
+        Aborting                // The transfer is aborting.  Unlike Cancelling, no compensating actions should be performed
     }
 
     /// <summary>
@@ -73,6 +77,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
     public class EntityTransferStateMachine
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[ENTITY TRANSFER STATE MACHINE]";
 
         /// <summary>
         /// If true then on a teleport, the source region waits for a callback from the destination region.  If
@@ -96,6 +101,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         /// <returns>true if the agent was not already in transit, false if it was</returns>
         internal bool SetInTransit(UUID id)
         {
+            m_log.DebugFormat("{0} SetInTransit. agent={1}, newState=Preparing", LogHeader, id);
             lock (m_agentsInTransit)
             {
                 if (!m_agentsInTransit.ContainsKey(id))
@@ -115,42 +121,117 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         /// <param name='newState'></param>
         /// <returns></returns>
         /// <exception cref='Exception'>Illegal transitions will throw an Exception</exception>
-        internal void UpdateInTransit(UUID id, AgentTransferState newState)
+        internal bool UpdateInTransit(UUID id, AgentTransferState newState)
         {
+            m_log.DebugFormat("{0} UpdateInTransit. agent={1}, newState={2}", LogHeader, id, newState);
+
+            bool transitionOkay = false;
+
+            // We don't want to throw an exception on cancel since this can come it at any time.
+            bool failIfNotOkay = true;
+
+            // Should be a failure message if failure is not okay.
+            string failureMessage = null;
+
+            AgentTransferState? oldState = null;
+
             lock (m_agentsInTransit)
             {
                 // Illegal to try and update an agent that's not actually in transit.
                 if (!m_agentsInTransit.ContainsKey(id))
-                    throw new Exception(
-                        string.Format(
-                            "Agent with ID {0} is not registered as in transit in {1}",
-                            id, m_mod.Scene.RegionInfo.RegionName));
-
-                AgentTransferState oldState = m_agentsInTransit[id];
+                {
+                    if (newState != AgentTransferState.Cancelling && newState != AgentTransferState.Aborting)
+                        failureMessage = string.Format(
+                                "Agent with ID {0} is not registered as in transit in {1}",
+                                id, m_mod.Scene.RegionInfo.RegionName);
+                    else
+                        failIfNotOkay = false;
+                }
+                else
+                {
+                    oldState = m_agentsInTransit[id];
 
-                bool transitionOkay = false;
+                    if (newState == AgentTransferState.Aborting)
+                    {
+                        transitionOkay = true;
+                    }
+                    else if (newState == AgentTransferState.CleaningUp && oldState != AgentTransferState.CleaningUp)
+                    {
+                        transitionOkay = true;
+                    }
+                    else if (newState == AgentTransferState.Transferring && oldState == AgentTransferState.Preparing)
+                    {
+                        transitionOkay = true;
+                    }
+                    else if (newState == AgentTransferState.ReceivedAtDestination && oldState == AgentTransferState.Transferring)
+                    {
+                        transitionOkay = true;
+                    }
+                    else
+                    {
+                        if (newState == AgentTransferState.Cancelling 
+                            && (oldState == AgentTransferState.Preparing || oldState == AgentTransferState.Transferring))
+                        {
+                            transitionOkay = true;
+                        }
+                        else
+                        {
+                            failIfNotOkay = false;
+                        }
+                    }
 
-                if (newState == AgentTransferState.CleaningUp && oldState != AgentTransferState.CleaningUp)
-                    transitionOkay = true;
-                else if (newState == AgentTransferState.Transferring && oldState == AgentTransferState.Preparing)
-                    transitionOkay = true;
-                else if (newState == AgentTransferState.ReceivedAtDestination && oldState == AgentTransferState.Transferring)
-                    transitionOkay = true;
+                    if (!transitionOkay)
+                        failureMessage 
+                            = string.Format(
+                                "Agent with ID {0} is not allowed to move from old transit state {1} to new state {2} in {3}",
+                                id, oldState, newState, m_mod.Scene.RegionInfo.RegionName);
+                }
 
                 if (transitionOkay)
+                {
                     m_agentsInTransit[id] = newState;
-                else
-                    throw new Exception(
-                        string.Format(
-                            "Agent with ID {0} is not allowed to move from old transit state {1} to new state {2} in {3}",
-                            id, oldState, newState, m_mod.Scene.RegionInfo.RegionName));
+
+//                    m_log.DebugFormat(
+//                        "[ENTITY TRANSFER STATE MACHINE]: Changed agent with id {0} from state {1} to {2} in {3}", 
+//                        id, oldState, newState, m_mod.Scene.Name);
+                }
+                else if (failIfNotOkay)
+                {
+                    m_log.DebugFormat("{0} UpdateInTransit. Throwing transition failure = {1}", LogHeader, failureMessage);
+                    throw new Exception(failureMessage);
+                }
+//                else
+//                {
+//                    if (oldState != null)
+//                        m_log.DebugFormat(
+//                            "[ENTITY TRANSFER STATE MACHINE]: Ignored change of agent with id {0} from state {1} to {2} in {3}", 
+//                            id, oldState, newState, m_mod.Scene.Name);
+//                    else
+//                        m_log.DebugFormat(
+//                            "[ENTITY TRANSFER STATE MACHINE]: Ignored change of agent with id {0} to state {1} in {2} since agent not in transit", 
+//                            id, newState, m_mod.Scene.Name);
+//                }
             }
+
+            return transitionOkay;
         }
 
-        internal bool IsInTransit(UUID id)
+        /// <summary>
+        /// Gets the current agent transfer state.
+        /// </summary>
+        /// <returns>Null if the agent is not in transit</returns>
+        /// <param name='id'>
+        /// Identifier.
+        /// </param>
+        internal AgentTransferState? GetAgentTransferState(UUID id)
         {
             lock (m_agentsInTransit)
-                return m_agentsInTransit.ContainsKey(id);
+            {
+                if (!m_agentsInTransit.ContainsKey(id))
+                    return null;
+                else
+                    return m_agentsInTransit[id];
+            }
         }
 
         /// <summary>
@@ -203,14 +284,14 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             
             lock (m_agentsInTransit)
             {
-                if (!IsInTransit(id))
+                AgentTransferState? currentState = GetAgentTransferState(id);
+
+                if (currentState == null)
                     throw new Exception(
                         string.Format(
                             "Asked to wait for destination callback for agent with ID {0} in {1} but agent is not in transit",
                             id, m_mod.Scene.RegionInfo.RegionName));
 
-                AgentTransferState currentState = m_agentsInTransit[id];
-
                 if (currentState != AgentTransferState.Transferring && currentState != AgentTransferState.ReceivedAtDestination)
                     throw new Exception(
                         string.Format(
@@ -222,8 +303,15 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             // There should be no race condition here since no other code should be removing the agent transfer or
             // changing the state to another other than Transferring => ReceivedAtDestination.
-            while (m_agentsInTransit[id] != AgentTransferState.ReceivedAtDestination && count-- > 0)
+
+            while (count-- > 0)
             {
+                lock (m_agentsInTransit)
+                {
+                    if (m_agentsInTransit[id] == AgentTransferState.ReceivedAtDestination)
+                        break;
+                }
+
 //                m_log.Debug("  >>> Waiting... " + count);
                 Thread.Sleep(100);
             }
diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs
index b188741..fa23590 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -31,6 +31,7 @@ using System.Reflection;
 
 using OpenSim.Framework;
 using OpenSim.Framework.Client;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Connectors.Hypergrid;
@@ -55,6 +56,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         private int m_levelHGTeleport = 0;
 
         private GatekeeperServiceConnector m_GatekeeperConnector;
+        private IUserAgentService m_UAS;
 
         protected bool m_RestrictAppearanceAbroad;
         protected string m_AccountName;
@@ -109,6 +111,11 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
         }
 
+        /// <summary>
+        /// Used for processing analysis of incoming attachments in a controlled fashion.
+        /// </summary>
+        private JobEngine m_incomingSceneObjectEngine;
+
         #region ISharedRegionModule
 
         public override string Name
@@ -152,39 +159,33 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             if (m_Enabled)
             {
                 scene.RegisterModuleInterface<IUserAgentVerificationModule>(this);
-                scene.EventManager.OnIncomingSceneObject += OnIncomingSceneObject;
-            }
-        }
-
-        void OnIncomingSceneObject(SceneObjectGroup so)
-        {
-            if (!so.IsAttachment)
-                return;
-
-            if (so.Scene.UserManagementModule.IsLocalGridUser(so.AttachedAvatar))
-                return;
-
-            // foreign user
-            AgentCircuitData aCircuit = so.Scene.AuthenticateHandler.GetAgentCircuitData(so.AttachedAvatar);
-            if (aCircuit != null && (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0)
-            {
-                if (aCircuit.ServiceURLs != null && aCircuit.ServiceURLs.ContainsKey("AssetServerURI"))
-                {
-                    string url = aCircuit.ServiceURLs["AssetServerURI"].ToString();
-                    m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Incoming attachement {0} for HG user {1} with asset server {2}", so.Name, so.AttachedAvatar, url);
-                    Dictionary<UUID, AssetType> ids = new Dictionary<UUID, AssetType>();
-                    HGUuidGatherer uuidGatherer = new HGUuidGatherer(so.Scene.AssetService, url);
-                    uuidGatherer.GatherAssetUuids(so, ids);
-
-                    foreach (KeyValuePair<UUID, AssetType> kvp in ids)
-                        uuidGatherer.FetchAsset(kvp.Key);
-                }
+                //scene.EventManager.OnIncomingSceneObject += OnIncomingSceneObject;
+
+                m_incomingSceneObjectEngine 
+                    = new JobEngine(
+                        string.Format("HG Incoming Scene Object Engine ({0})", scene.Name), 
+                        "HG INCOMING SCENE OBJECT ENGINE");
+
+                StatsManager.RegisterStat(
+                    new Stat(
+                        "HGIncomingAttachmentsWaiting",
+                        "Number of incoming attachments waiting for processing.",
+                        "",
+                        "",
+                        "entitytransfer",
+                        Name,
+                        StatType.Pull,
+                        MeasuresOfInterest.None,
+                        stat => stat.Value = m_incomingSceneObjectEngine.JobsWaiting,
+                        StatVerbosity.Debug));
+
+                m_incomingSceneObjectEngine.Start();
             }
         }
 
         protected override void OnNewClient(IClientAPI client)
         {
-            client.OnTeleportHomeRequest += TeleportHome;
+            client.OnTeleportHomeRequest += TriggerTeleportHome;
             client.OnTeleportLandmarkRequest += RequestTeleportLandmark;
             client.OnConnectionClosed += new Action<IClientAPI>(OnConnectionClosed);
         }
@@ -194,34 +195,44 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             base.RegionLoaded(scene);
 
             if (m_Enabled)
+            {
                 m_GatekeeperConnector = new GatekeeperServiceConnector(scene.AssetService);
+                m_UAS = scene.RequestModuleInterface<IUserAgentService>();
+                if (m_UAS == null)
+                    m_UAS = new UserAgentServiceConnector(m_ThisHomeURI);
+
+            }
         }
 
         public override void RemoveRegion(Scene scene)
         {
-            base.AddRegion(scene);
+            base.RemoveRegion(scene);
 
             if (m_Enabled)
+            {
                 scene.UnregisterModuleInterface<IUserAgentVerificationModule>(this);
+                m_incomingSceneObjectEngine.Stop();
+            }
         }
 
         #endregion
 
-        #region HG overrides of IEntiryTransferModule
+        #region HG overrides of IEntityTransferModule
 
-        protected override GridRegion GetFinalDestination(GridRegion region)
+        protected override GridRegion GetFinalDestination(GridRegion region, UUID agentID, string agentHomeURI, out string message)
         {
             int flags = Scene.GridService.GetRegionFlags(Scene.RegionInfo.ScopeID, region.RegionID);
             m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: region {0} flags: {1}", region.RegionName, flags);
+            message = null;
 
             if ((flags & (int)OpenSim.Framework.RegionFlags.Hyperlink) != 0)
             {
                 m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Destination region is hyperlink");
-                GridRegion real_destination = m_GatekeeperConnector.GetHyperlinkRegion(region, region.RegionID);
+                GridRegion real_destination = m_GatekeeperConnector.GetHyperlinkRegion(region, region.RegionID, agentID, agentHomeURI, out message);
                 if (real_destination != null)
-                    m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: GetFinalDestination serveruri -> {0}", real_destination.ServerURI);
+                    m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: GetFinalDestination: ServerURI={0}", real_destination.ServerURI);
                 else
-                    m_log.WarnFormat("[HG ENTITY TRANSFER MODULE]: GetHyperlinkRegion to Gatekeeper {0} failed", region.ServerURI);
+                    m_log.WarnFormat("[HG ENTITY TRANSFER MODULE]: GetHyperlinkRegion of region {0} from Gatekeeper {1} failed: {2}", region.RegionID, region.ServerURI, message);
                 return real_destination;
             }
 
@@ -272,12 +283,21 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 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);
+                    IUserAgentService connector;
+
+                    if (userAgentDriver.Equals(m_ThisHomeURI) && m_UAS != null)
+                        connector = m_UAS;
+                    else
+                        connector = new UserAgentServiceConnector(userAgentDriver);
+
+                    GridRegion source = new GridRegion(Scene.RegionInfo);
+                    source.RawServerURI = m_GatekeeperURI;
+                    
+                    bool success = connector.LoginAgentToGrid(source, agentCircuit, reg, finalDestination, false, out reason);
                     logout = success; // flag for later logout from this grid; this is an HG TP
 
                     if (success)
-                        sp.Scene.EventManager.TriggerTeleportStart(sp.ControllingClient, reg, finalDestination, teleportFlags, logout);
+                        Scene.EventManager.TriggerTeleportStart(sp.ControllingClient, reg, finalDestination, teleportFlags, logout);
 
                     return success;
                 }
@@ -409,7 +429,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         //    return base.UpdateAgent(reg, finalDestination, agentData, sp);
         //}
 
-        public override void TeleportHome(UUID id, IClientAPI client)
+        public override void TriggerTeleportHome(UUID id, IClientAPI client)     
+        {                                                                       
+            TeleportHome(id, client);                                           
+        }                                                                       
+                          
+        public override bool TeleportHome(UUID id, IClientAPI client)
         {
             m_log.DebugFormat(
                 "[ENTITY TRANSFER MODULE]: Request to teleport {0} {1} home", client.Name, client.AgentId);
@@ -420,8 +445,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             {
                 // local grid user
                 m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: User is local");
-                base.TeleportHome(id, client);
-                return;
+                return base.TeleportHome(id, client);
             }
 
             // Foreign user wants to go home
@@ -431,17 +455,27 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             {
                 client.SendTeleportFailed("Your information has been lost");
                 m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Unable to locate agent's gateway information");
-                return;
+                return false;
             }
 
             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);
+
+            GridRegion finalDestination = null;
+            try
+            {
+                finalDestination = userAgentService.GetHomeRegion(aCircuit.AgentID, out position, out lookAt);
+            }
+            catch (Exception e)
+            {
+                m_log.Debug("[HG ENTITY TRANSFER MODULE]: GetHomeRegion call failed ", e);
+            }
+            
             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;
+                return false;
             }
 
             ScenePresence sp = ((Scene)(client.Scene)).GetScenePresence(client.AgentId);
@@ -449,7 +483,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             {
                 client.SendTeleportFailed("Internal error");
                 m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Agent not found in the scene where it is supposed to be");
-                return;
+                return false;
             }
 
             GridRegion homeGatekeeper = MakeRegion(aCircuit);
@@ -460,6 +494,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             DoTeleport(
                 sp, homeGatekeeper, finalDestination,
                 position, lookAt, (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaHome));
+            return true;
         }
 
         /// <summary>
@@ -484,35 +519,174 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             // Local region?
             if (info != null)
             {
-                ((Scene)(remoteClient.Scene)).RequestTeleportLocation(remoteClient, info.RegionHandle, lm.Position,
+                Scene.RequestTeleportLocation(
+                    remoteClient, info.RegionHandle, lm.Position,
                     Vector3.Zero, (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaLandmark));
-
-                return;
             }
             else 
             {
                 // Foreign region
-                Scene scene = (Scene)(remoteClient.Scene);
                 GatekeeperServiceConnector gConn = new GatekeeperServiceConnector();
                 GridRegion gatekeeper = new GridRegion();
                 gatekeeper.ServerURI = lm.Gatekeeper;
-                GridRegion finalDestination = gConn.GetHyperlinkRegion(gatekeeper, new UUID(lm.RegionID));
+                string homeURI = Scene.GetAgentHomeURI(remoteClient.AgentId);
+
+                string message;
+                GridRegion finalDestination = gConn.GetHyperlinkRegion(gatekeeper, new UUID(lm.RegionID), remoteClient.AgentId, homeURI, out message);
 
                 if (finalDestination != null)
                 {
-                    ScenePresence sp = scene.GetScenePresence(remoteClient.AgentId);
-                    IEntityTransferModule transferMod = scene.RequestModuleInterface<IEntityTransferModule>();
+                    ScenePresence sp = Scene.GetScenePresence(remoteClient.AgentId);
 
-                    if (transferMod != null && sp != null)
-                        transferMod.DoTeleport(
+                    if (sp != null)
+                    {
+                        if (message != null)
+                            sp.ControllingClient.SendAgentAlertMessage(message, true);
+
+                        // Validate assorted conditions
+                        string reason = string.Empty;
+                        if (!ValidateGenericConditions(sp, gatekeeper, finalDestination, 0, out reason))
+                        {
+                            sp.ControllingClient.SendTeleportFailed(reason);
+                            return;
+                        }
+
+                        DoTeleport(
                             sp, gatekeeper, finalDestination, lm.Position, Vector3.UnitX,
                             (uint)(Constants.TeleportFlags.SetLastToTarget | Constants.TeleportFlags.ViaLandmark));
+                    }
+                }
+                else
+                {
+                    remoteClient.SendTeleportFailed(message);
                 }
 
             }
+        }
+
+        private void RemoveIncomingSceneObjectJobs(string commonIdToRemove)
+        {
+            List<JobEngine.Job> jobsToReinsert = new List<JobEngine.Job>();
+            int jobsRemoved = 0;
 
-            // can't find the region: Tell viewer and abort
-            remoteClient.SendTeleportFailed("The teleport destination could not be found.");
+            JobEngine.Job job;
+            while ((job = m_incomingSceneObjectEngine.RemoveNextJob()) != null)
+            {
+                if (job.CommonId != commonIdToRemove)
+                    jobsToReinsert.Add(job);
+                else
+                    jobsRemoved++;
+            }
+
+            m_log.DebugFormat(
+                "[HG ENTITY TRANSFER]: Removing {0} jobs with common ID {1} and reinserting {2} other jobs",
+                jobsRemoved, commonIdToRemove, jobsToReinsert.Count);
+
+            if (jobsToReinsert.Count > 0)
+            {                                        
+                foreach (JobEngine.Job jobToReinsert in jobsToReinsert)
+                    m_incomingSceneObjectEngine.QueueJob(jobToReinsert);
+            }
+        }
+
+        public override bool HandleIncomingSceneObject(SceneObjectGroup so, Vector3 newPosition)
+        {
+            // FIXME: We must make it so that we can use SOG.IsAttachment here.  At the moment it is always null!
+            if (!so.IsAttachmentCheckFull())
+                return base.HandleIncomingSceneObject(so, newPosition);
+
+            // Equally, we can't use so.AttachedAvatar here.
+            if (so.OwnerID == UUID.Zero || Scene.UserManagementModule.IsLocalGridUser(so.OwnerID))
+                return base.HandleIncomingSceneObject(so, newPosition);
+
+            // foreign user
+            AgentCircuitData aCircuit = Scene.AuthenticateHandler.GetAgentCircuitData(so.OwnerID);
+            if (aCircuit != null)
+            {
+                if ((aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) == 0)
+                {
+                    // We have already pulled the necessary attachments from the source grid.
+                    base.HandleIncomingSceneObject(so, newPosition);
+                }
+                else
+                {
+                    if (aCircuit.ServiceURLs != null && aCircuit.ServiceURLs.ContainsKey("AssetServerURI"))
+                    {
+                        m_incomingSceneObjectEngine.QueueJob(
+                            string.Format("HG UUID Gather for attachment {0} for {1}", so.Name, aCircuit.Name), 
+                            () => 
+                            {
+                                string url = aCircuit.ServiceURLs["AssetServerURI"].ToString();
+    //                            m_log.DebugFormat(
+    //                                "[HG ENTITY TRANSFER MODULE]: Incoming attachment {0} for HG user {1} with asset service {2}", 
+    //                                so.Name, so.AttachedAvatar, url);
+
+                                IDictionary<UUID, sbyte> ids = new Dictionary<UUID, sbyte>();
+                                HGUuidGatherer uuidGatherer 
+                                    = new HGUuidGatherer(Scene.AssetService, url, ids);
+                                uuidGatherer.AddForInspection(so);
+
+                                while (!uuidGatherer.Complete)
+                                {
+                                    int tickStart = Util.EnvironmentTickCount();
+
+                                    UUID? nextUuid = uuidGatherer.NextUuidToInspect;
+                                    uuidGatherer.GatherNext();
+
+    //                                m_log.DebugFormat(
+    //                                    "[HG ENTITY TRANSFER]: Gathered attachment asset uuid {0} for object {1} for HG user {2} took {3} ms with asset service {4}",
+    //                                    nextUuid, so.Name, so.OwnerID, Util.EnvironmentTickCountSubtract(tickStart), url);
+
+                                    int ticksElapsed = Util.EnvironmentTickCountSubtract(tickStart);
+
+                                    if (ticksElapsed > 30000)
+                                    {
+                                        m_log.WarnFormat(
+                                            "[HG ENTITY TRANSFER]: Removing incoming scene object jobs for HG user {0} as gather of {1} from {2} took {3} ms to respond (> {4} ms)",
+                                            so.OwnerID, so.Name, url, ticksElapsed, 30000);
+
+                                        RemoveIncomingSceneObjectJobs(so.OwnerID.ToString());
+
+                                        return;
+                                    }                                                           
+                                }
+
+    //                            m_log.DebugFormat(
+    //                                "[HG ENTITY TRANSFER]: Fetching {0} assets for attachment {1} for HG user {2} with asset service {3}",
+    //                                ids.Count, so.Name, so.OwnerID, url);
+
+                                foreach (KeyValuePair<UUID, sbyte> kvp in ids)
+                                {
+                                    int tickStart = Util.EnvironmentTickCount();
+
+                                    uuidGatherer.FetchAsset(kvp.Key);   
+
+                                    int ticksElapsed = Util.EnvironmentTickCountSubtract(tickStart);
+
+                                    if (ticksElapsed > 30000)
+                                    {
+                                        m_log.WarnFormat(
+                                            "[HG ENTITY TRANSFER]: Removing incoming scene object jobs for HG user {0} as fetch of {1} from {2} took {3} ms to respond (> {4} ms)",
+                                            so.OwnerID, kvp.Key, url, ticksElapsed, 30000);
+
+                                        RemoveIncomingSceneObjectJobs(so.OwnerID.ToString());
+
+                                        return;
+                                    }   
+                                }
+
+                                base.HandleIncomingSceneObject(so, newPosition);
+
+    //                            m_log.DebugFormat(
+    //                                "[HG ENTITY TRANSFER MODULE]: Completed incoming attachment {0} for HG user {1} with asset server {2}", 
+    //                                so.Name, so.OwnerID, url);
+                            },                             
+                            so.OwnerID.ToString());
+                    }
+                }
+            }
+
+            return true;
         }
 
         #endregion
@@ -549,12 +723,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             if (uMan != null && uMan.IsLocalGridUser(obj.AgentId))
             {
                 // local grid user
+                m_UAS.LogoutAgent(obj.AgentId, obj.SessionId);
                 return;
             }
 
             AgentCircuitData aCircuit = ((Scene)(obj.Scene)).AuthenticateHandler.GetAgentCircuitData(obj.CircuitCode);
-
-            if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
+            if (aCircuit != null && aCircuit.ServiceURLs != null && aCircuit.ServiceURLs.ContainsKey("HomeURI"))
             {
                 string url = aCircuit.ServiceURLs["HomeURI"].ToString();
                 IUserAgentService security = new UserAgentServiceConnector(url);