16 files changed, 949 insertions, 184 deletions

diff --git a/OpenSim/Region/CoreModules/Framework/Caps/CapabilitiesModule.cs b/OpenSim/Region/CoreModules/Framework/Caps/CapabilitiesModule.cs
index 7f30e5a..2eb9bfb 100644
--- a/OpenSim/Region/CoreModules/Framework/Caps/CapabilitiesModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/Caps/CapabilitiesModule.cs
@@ -55,7 +55,7 @@ namespace OpenSim.Region.CoreModules.Framework
         /// <summary>
         /// Each agent has its own capabilities handler.
         /// </summary>
-        protected Dictionary<UUID, Caps> m_capsObjects = new Dictionary<UUID, Caps>();
+        protected Dictionary<uint, Caps> m_capsObjects = new Dictionary<uint, Caps>();
         
         protected Dictionary<UUID, string> capsPaths = new Dictionary<UUID, string>();
         protected Dictionary<UUID, Dictionary<ulong, string>> childrenSeeds 
@@ -100,7 +100,7 @@ namespace OpenSim.Region.CoreModules.Framework
             get { return null; }
         }
 
-        public void CreateCaps(UUID agentId)
+        public void CreateCaps(UUID agentId, uint circuitCode)
         {
             int flags = m_scene.GetUserFlags(agentId);
             if (m_scene.RegionInfo.EstateSettings.IsBanned(agentId, flags))
@@ -108,9 +108,9 @@ namespace OpenSim.Region.CoreModules.Framework
 
             String capsObjectPath = GetCapsPath(agentId);
 
-            if (m_capsObjects.ContainsKey(agentId))
+            if (m_capsObjects.ContainsKey(circuitCode))
             {
-                Caps oldCaps = m_capsObjects[agentId];
+                Caps oldCaps = m_capsObjects[circuitCode];
                 
                 m_log.DebugFormat(
                     "[CAPS]: Recreating caps for agent {0}.  Old caps path {1}, new caps path {2}. ", 
@@ -125,12 +125,12 @@ namespace OpenSim.Region.CoreModules.Framework
                     (MainServer.Instance == null) ? 0: MainServer.Instance.Port,
                     capsObjectPath, agentId, m_scene.RegionInfo.RegionName);
 
-            m_capsObjects[agentId] = caps;
+            m_capsObjects[circuitCode] = caps;
 
             m_scene.EventManager.TriggerOnRegisterCaps(agentId, caps);
         }
 
-        public void RemoveCaps(UUID agentId)
+        public void RemoveCaps(UUID agentId, uint circuitCode)
         {
             if (childrenSeeds.ContainsKey(agentId))
             {
@@ -139,11 +139,11 @@ namespace OpenSim.Region.CoreModules.Framework
 
             lock (m_capsObjects)
             {
-                if (m_capsObjects.ContainsKey(agentId))
+                if (m_capsObjects.ContainsKey(circuitCode))
                 {
-                    m_capsObjects[agentId].DeregisterHandlers();
-                    m_scene.EventManager.TriggerOnDeregisterCaps(agentId, m_capsObjects[agentId]);
-                    m_capsObjects.Remove(agentId);
+                    m_capsObjects[circuitCode].DeregisterHandlers();
+                    m_scene.EventManager.TriggerOnDeregisterCaps(agentId, m_capsObjects[circuitCode]);
+                    m_capsObjects.Remove(circuitCode);
                 }
                 else
                 {
@@ -154,19 +154,30 @@ namespace OpenSim.Region.CoreModules.Framework
             }
         }
         
-        public Caps GetCapsForUser(UUID agentId)
+        public Caps GetCapsForUser(uint circuitCode)
         {
             lock (m_capsObjects)
             {
-                if (m_capsObjects.ContainsKey(agentId))
+                if (m_capsObjects.ContainsKey(circuitCode))
                 {
-                    return m_capsObjects[agentId];
+                    return m_capsObjects[circuitCode];
                 }
             }
             
             return null;
         }
         
+        public void ActivateCaps(uint circuitCode)
+        {
+            lock (m_capsObjects)
+            {
+                if (m_capsObjects.ContainsKey(circuitCode))
+                {
+                    m_capsObjects[circuitCode].Activate();
+                }
+            }
+        }
+
         public void SetAgentCapsSeeds(AgentCircuitData agent)
         {
             capsPaths[agent.AgentID] = agent.CapsPath;
@@ -237,9 +248,9 @@ namespace OpenSim.Region.CoreModules.Framework
             StringBuilder caps = new StringBuilder();
             caps.AppendFormat("Region {0}:\n", m_scene.RegionInfo.RegionName);
 
-            foreach (KeyValuePair<UUID, Caps> kvp in m_capsObjects)
+            foreach (KeyValuePair<uint, Caps> kvp in m_capsObjects)
             {
-                caps.AppendFormat("** User {0}:\n", kvp.Key);
+                caps.AppendFormat("** Circuit {0}:\n", kvp.Key);
 
                 for (IDictionaryEnumerator kvp2 = kvp.Value.CapsHandlers.GetCapsDetails(false).GetEnumerator(); kvp2.MoveNext(); )
                 {
diff --git a/OpenSim/Region/CoreModules/Framework/DynamicAttributes/DAExampleModule.cs b/OpenSim/Region/CoreModules/Framework/DynamicAttributes/DAExampleModule.cs
new file mode 100644
index 0000000..1f1568f
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Framework/DynamicAttributes/DAExampleModule.cs
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Framework.DynamicAttributes.DAExampleModule
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "DAExampleModule")]
+    public class DAExampleModule : INonSharedRegionModule
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static readonly bool ENABLED = false;   // enable for testing
+
+        public const string DANamespace = "DAExample Module";
+
+        protected Scene m_scene;
+        protected IDialogModule m_dialogMod;
+        
+        public string Name { get { return "DAExample Module"; } }        
+        public Type ReplaceableInterface { get { return null; } }        
+
+        public void Initialise(IConfigSource source) {}
+        
+        public void AddRegion(Scene scene)
+        {
+            if (ENABLED)
+            {
+                m_scene = scene;
+                m_scene.EventManager.OnSceneGroupMove += OnSceneGroupMove;
+                m_dialogMod = m_scene.RequestModuleInterface<IDialogModule>();
+            }
+        }
+        
+        public void RemoveRegion(Scene scene) 
+        {
+            if (ENABLED)
+            {
+                m_scene.EventManager.OnSceneGroupMove -= OnSceneGroupMove;
+            }
+        }
+        
+        public void RegionLoaded(Scene scene) {}
+        
+        public void Close() 
+        {
+            RemoveRegion(m_scene);
+        }
+        
+        protected bool OnSceneGroupMove(UUID groupId, Vector3 delta)
+        {
+            OSDMap attrs = null;
+            SceneObjectPart sop = m_scene.GetSceneObjectPart(groupId);
+
+            if (sop == null)
+                return true;
+
+            if (!sop.DynAttrs.TryGetValue(DANamespace, out attrs))
+                attrs = new OSDMap();
+            
+            OSDInteger newValue;
+
+            // We have to lock on the entire dynamic attributes map to avoid race conditions with serialization code.
+            lock (sop.DynAttrs)            
+            {
+                if (!attrs.ContainsKey("moves"))
+                    newValue = new OSDInteger(1);
+                else
+                    newValue = new OSDInteger(attrs["moves"].AsInteger() + 1);
+                        
+                attrs["moves"] = newValue;
+
+                sop.DynAttrs[DANamespace] = attrs;
+            }
+
+            sop.ParentGroup.HasGroupChanged = true;
+    
+            m_dialogMod.SendGeneralAlert(string.Format("{0} {1} moved {2} times", sop.Name, sop.UUID, newValue));
+            
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Framework/DynamicAttributes/DOExampleModule.cs b/OpenSim/Region/CoreModules/Framework/DynamicAttributes/DOExampleModule.cs
new file mode 100644
index 0000000..650aa35
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Framework/DynamicAttributes/DOExampleModule.cs
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.CoreModules.Framework.DynamicAttributes.DAExampleModule;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.Framework.DynamicAttributes.DOExampleModule
+{
+    /// <summary>
+    /// Example module for experimenting with and demonstrating dynamic object ideas.
+    /// </summary>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "DOExampleModule")]
+    public class DOExampleModule : INonSharedRegionModule
+    {
+        public class MyObject
+        {
+            public int Moves { get; set; }
+
+            public MyObject(int moves)
+            {
+                Moves = moves;
+            }
+        }
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static readonly bool ENABLED = false;   // enable for testing
+
+        private Scene m_scene;
+        private IDialogModule m_dialogMod;
+        
+        public string Name { get { return "DOExample Module"; } }        
+        public Type ReplaceableInterface { get { return null; } }        
+
+        public void Initialise(IConfigSource source) {}
+        
+        public void AddRegion(Scene scene)
+        {
+            if (ENABLED)
+            {
+                m_scene = scene;
+                m_scene.EventManager.OnObjectAddedToScene += OnObjectAddedToScene;
+                m_scene.EventManager.OnSceneGroupMove += OnSceneGroupMove;
+                m_dialogMod = m_scene.RequestModuleInterface<IDialogModule>();
+            }
+        }
+        
+        public void RemoveRegion(Scene scene) 
+        {
+            if (ENABLED)
+            {
+                m_scene.EventManager.OnSceneGroupMove -= OnSceneGroupMove;
+            }
+        }
+        
+        public void RegionLoaded(Scene scene) {}
+        
+        public void Close() 
+        {
+            RemoveRegion(m_scene);
+        }
+
+        private void OnObjectAddedToScene(SceneObjectGroup so)
+        {
+            SceneObjectPart rootPart = so.RootPart;
+
+            OSDMap attrs;
+
+            int movesSoFar = 0;
+
+//            Console.WriteLine("Here for {0}", so.Name);
+
+            if (rootPart.DynAttrs.TryGetValue(DAExampleModule.DANamespace, out attrs))
+            {
+                movesSoFar = attrs["moves"].AsInteger();
+
+                m_log.DebugFormat(
+                    "[DO EXAMPLE MODULE]: Found saved moves {0} for {1} in {2}", movesSoFar, so.Name, m_scene.Name);
+            }
+
+            rootPart.DynObjs.Add(Name, new MyObject(movesSoFar));
+        }
+        
+        private bool OnSceneGroupMove(UUID groupId, Vector3 delta)
+        {
+            SceneObjectGroup so = m_scene.GetSceneObjectGroup(groupId);
+
+            if (so == null)
+                return true;
+
+            object rawObj = so.RootPart.DynObjs.Get(Name);
+
+            if (rawObj != null)
+            {
+                MyObject myObj = (MyObject)rawObj;
+               
+                m_dialogMod.SendGeneralAlert(string.Format("{0} {1} moved {2} times", so.Name, so.UUID, ++myObj.Moves));
+            }
+            
+            return true;
+        }        
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
index cb09047..b70aeb7 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
@@ -33,6 +33,7 @@ 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;
@@ -66,6 +67,42 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         /// </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 bool m_Enabled = false;
 
         public Scene Scene { get; private set; }
@@ -80,6 +117,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 new ExpiringCache<UUID, ExpiringCache<ulong, DateTime>>();
 
         private IEventQueue m_eqModule;
+        private IRegionCombinerModule m_regionCombinerModule;
 
         #region ISharedRegionModule
 
@@ -116,6 +154,9 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             IConfig transferConfig = source.Configs["EntityTransfer"];
             if (transferConfig != null)
             {
+                DisableInterRegionTeleportCancellation 
+                    = transferConfig.GetBoolean("DisableInterRegionTeleportCancellation", false);
+
                 WaitForAgentArrivedAtDestination
                     = transferConfig.GetBoolean("wait_for_callback", WaitForAgentArrivedAtDestinationDefault);
                 
@@ -142,6 +183,60 @@ 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;
         }
@@ -150,12 +245,25 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         {
             client.OnTeleportHomeRequest += TriggerTeleportHome;
             client.OnTeleportLandmarkRequest += RequestTeleportLandmark;
-            client.OnTeleportCancel += TeleportCancel;
+
+            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)
         {
@@ -163,12 +271,33 @@ 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);
+        }
+
         public void Teleport(ScenePresence sp, ulong regionHandle, Vector3 position, Vector3 lookAt, uint teleportFlags)
         {
             if (sp.Scene.Permissions.IsGridGod(sp.UUID))
@@ -180,13 +309,24 @@ 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);
+                
+                return;
+            }
+
             try
             {
+                // Reset animations; the viewer does that in teleports.
+                sp.Animator.ResetAnimations();
+
                 if (regionHandle == sp.Scene.RegionInfo.RegionHandle)
                 {
                     destinationRegionName = sp.Scene.RegionInfo.RegionName;
@@ -195,12 +335,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)
@@ -210,11 +355,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>
@@ -230,23 +376,14 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 "[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)
             {
                 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;
             }
@@ -287,7 +424,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
 
             m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.CleaningUp);
-            m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
         }
 
         /// <summary>
@@ -341,7 +477,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 //
                 // This is it
                 //
-                DoTeleport(sp, reg, finalDestination, position, lookAt, teleportFlags);
+                DoTeleportInternal(sp, reg, finalDestination, position, lookAt, teleportFlags);
                 //
                 //
                 //
@@ -396,27 +532,54 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 && 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)
         {
             // 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.
-            m_entityTransferStateMachine.SetInTransit(sp.UUID);
-//            if (!m_entityTransferStateMachine.SetInTransit(sp.UUID))
-//            {
-//                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);
-//
-//                return;
-//            }
+            if (!m_entityTransferStateMachine.SetInTransit(sp.UUID))
+            {
+                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);
 
-            if (reg == null || finalDestination == null)
+                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);
+
+                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;
             }
 
@@ -436,8 +599,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                       sourceRegion.RegionName, sourceRegion.RegionLocX, sourceRegion.RegionLocY,
                       MaxTransferDistance));
 
-                m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
-
                 return;
             }
 
@@ -455,7 +616,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             if (endPoint == null || endPoint.Address == null)
             {
                 sp.ControllingClient.SendTeleportFailed("Remote Region appears to be down");
-                m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
 
                 return;
             }
@@ -465,19 +625,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     "[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;
-//                }
-
             string reason;
             string version;
             if (!Scene.SimulationService.QueryAccess(
                 finalDestination, sp.ControllingClient.AgentId, Vector3.Zero, out version, 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}",
@@ -486,6 +639,11 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 return;
             }
 
+            // 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]: Destination is running version {0}", version);
 
             // Fixing a bug where teleporting while sitting results in the avatar ending up removed from
@@ -495,6 +653,9 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             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).
             sp.ControllingClient.SendTeleportStart(teleportFlags);
@@ -531,11 +692,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
 
             // 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++;
+
                 sp.ControllingClient.SendTeleportFailed(String.Format("Teleport refused: {0}", reason));
-                m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
 
                 m_log.DebugFormat(
                     "[ENTITY TRANSFER MODULE]: Teleport of {0} from {1} to {2} was refused because {3}",
@@ -544,6 +707,27 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 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);
 
@@ -553,6 +737,10 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             IClientIPEndpoint ipepClient;  
             if (NeedsNewAgent(sp.DrawDistance, 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
@@ -565,11 +753,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
                 if (m_eqModule != null)
                 {
+                    // 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);
 
-                    // ES makes the client send a UseCircuitCode message to the destination, 
-                    // which triggers a bunch of things there.
-                    // So let's wait
+                    // 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
@@ -580,6 +770,9 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 }
                 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);
                 }
             }
@@ -597,23 +790,66 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             //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.",
+                    "[ENTITY TRANSFER MODULE]: UpdateAgent failed on teleport of {0} to {1} from {2}.  Keeping avatar in source region.",
                     sp.Name, finalDestination.RegionName, sp.Scene.RegionInfo.RegionName);
                 
-                Fail(sp, finalDestination, logout);
+                Fail(sp, finalDestination, logout, "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, 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;
+
             if (m_eqModule != null)
             {
                 m_eqModule.TeleportFinishEvent(destinationHandle, 13, endPoint, 0, teleportFlags, capsPath, sp.UUID);
@@ -624,19 +860,28 @@ 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, "Destination region did not signal teleport completion.");
+
                 return;
             }
 
@@ -659,8 +904,6 @@ 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))
@@ -680,27 +923,21 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 // 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);
-//            }
-
-            m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
         }
 
-        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, 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.");
-
-            // Fail. Reset it back
             sp.IsChildAgent = false;
             ReInstantiateScripts(sp);
 
@@ -708,10 +945,26 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             // Finally, kill the agent we just created at the destination.
             Scene.SimulationService.CloseAgent(finalDestination, sp.UUID);
+        }
 
-            sp.Scene.EventManager.TriggerTeleportFail(sp.ControllingClient, logout);
+        /// <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 reason)
+        {
+            CleanupFailedInterRegionTeleport(sp, finalDestination);
+
+            m_interRegionTeleportFailures.Value++;
 
-            m_entityTransferStateMachine.ResetFromTransit(sp.UUID);
+            sp.ControllingClient.SendTeleportFailed(
+                string.Format(
+                    "Problems connecting to destination {0}, reason: {1}", finalDestination.RegionName, reason));
+
+            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)
@@ -762,7 +1015,21 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         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)
@@ -866,6 +1133,10 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         {
             version = String.Empty;
             newpos = new Vector3(pos.X, pos.Y, pos.Z);
+
+//            m_log.DebugFormat(
+//                "[ENTITY TRANSFER MODULE]: Crossing agent {0} at pos {1} in {2}", agent.Name, pos, scene.Name);
+
             uint neighbourx = scene.RegionInfo.RegionLocX;
             uint neighboury = scene.RegionInfo.RegionLocY;
             const float boundaryDistance = 1.7f;
@@ -995,11 +1266,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             return neighbourRegion;
         }
 
-        private void TeleportCancel(IClientAPI remoteClient)
-        {
-            m_entityTransferStateMachine.ResetFromTransit(remoteClient.AgentId);
-        }
-
         public bool Cross(ScenePresence agent, bool isFlying)
         {
             uint x;
@@ -1023,16 +1289,16 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         }
 
 
-        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);
@@ -1042,7 +1308,19 @@ 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, 
+                Utils.UIntsToLong(regionX * (uint)Constants.RegionSize, regionY * (uint)Constants.RegionSize), 
+                position, 
+                agent.Lookat, 
+                (uint)Constants.TeleportFlags.ViaLocation);
+
+            /*
             IMessageTransferModule im = initiatingScene.RequestModuleInterface<IMessageTransferModule>();
             if (im != null)
             {
@@ -1077,12 +1355,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 });
 
             }
+            */
         }
 
         private void InformClientToInitiateTeleportToLocationCompleted(IAsyncResult iar)
         {
-            InformClientToInitateTeleportToLocationDelegate icon =
-                (InformClientToInitateTeleportToLocationDelegate)iar.AsyncState;
+            InformClientToInitiateTeleportToLocationDelegate icon =
+                (InformClientToInitiateTeleportToLocationDelegate)iar.AsyncState;
             icon.EndInvoke(iar);
         }
 
@@ -1107,10 +1386,16 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             bool isFlying, string version)
         {
             if (!CrossAgentToNewRegionPrep(agent, neighbourRegion))
+            {
+                m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
                 return agent;
+            }
 
             if (!CrossAgentIntoNewRegionMain(agent, pos, neighbourRegion, isFlying))
+            {
+                m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
                 return agent;
+            }
 
             CrossAgentToNewRegionPost(agent, pos, neighbourRegion, isFlying, version);
             return agent;
@@ -1137,9 +1422,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     // 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 false;
                 }
@@ -1576,6 +1864,37 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         }
 
         /// <summary>
+        /// 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)
+        {
+            Border[] northBorders = Scene.NorthBorders.ToArray();
+            Border[] eastBorders = Scene.EastBorders.ToArray();
+
+            Vector2 extent = Vector2.Zero;
+            for (int i = 0; i < eastBorders.Length; i++)
+            {
+                extent.X = (eastBorders[i].BorderLine.Z > extent.X) ? eastBorders[i].BorderLine.Z : extent.X;
+            }
+            for (int i = 0; i < northBorders.Length; i++)
+            {
+                extent.Y = (northBorders[i].BorderLine.Z > extent.Y) ? northBorders[i].BorderLine.Z : extent.Y;
+            }
+
+            // Loss of fraction on purpose
+            extent.X = ((int)extent.X / (int)Constants.RegionSize);
+            extent.Y = ((int)extent.Y / (int)Constants.RegionSize);
+
+            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 regions that are considered to be neighbours to the given scene.
         /// </summary>
         /// <param name="pScene"></param>
@@ -1587,15 +1906,10 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             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();
-
             // 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;
 
@@ -1613,27 +1927,17 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
             else
             {
-                Vector2 extent = Vector2.Zero;
-                for (int i = 0; i < eastBorders.Length; i++)
-                {
-                    extent.X = (eastBorders[i].BorderLine.Z > extent.X) ? eastBorders[i].BorderLine.Z : extent.X;
-                }
-                for (int i = 0; i < northBorders.Length; i++)
-                {
-                    extent.Y = (northBorders[i].BorderLine.Z > extent.Y) ? northBorders[i].BorderLine.Z : extent.Y;
-                }
-
-                // Loss of fraction on purpose
-                extent.X = ((int)extent.X / (int)Constants.RegionSize) + 1;
-                extent.Y = ((int)extent.Y / (int)Constants.RegionSize) + 1;
-
-                int startX = (int)(pRegionLocX - 1) * (int)Constants.RegionSize;
-                int startY = (int)(pRegionLocY - 1) * (int)Constants.RegionSize;
+                Vector2 swCorner, neCorner;
+                GetMegaregionViewRange(out swCorner, out neCorner);
 
-                int endX = ((int)pRegionLocX + (int)extent.X) * (int)Constants.RegionSize;
-                int endY = ((int)pRegionLocY + (int)extent.Y) * (int)Constants.RegionSize;
+                List<GridRegion> neighbours 
+                    = pScene.GridService.GetRegionRange(
+                        m_regionInfo.ScopeID, 
+                        (int)swCorner.X * (int)Constants.RegionSize, 
+                        (int)neCorner.X * (int)Constants.RegionSize,
+                        (int)swCorner.Y * (int)Constants.RegionSize,
+                        (int)neCorner.Y * (int)Constants.RegionSize);
 
-                List<GridRegion> neighbours = pScene.GridService.GetRegionRange(m_regionInfo.ScopeID, startX, endX, startY, endY);
                 neighbours.RemoveAll(delegate(GridRegion r) { return r.RegionID == m_regionInfo.RegionID; });
 
                 return neighbours;
@@ -2054,7 +2358,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)
diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs
index 70dd1bc..e903383 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs
@@ -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>
@@ -115,42 +119,114 @@ 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)
         {
+            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)
+                {
+                    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 +279,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 +298,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 f3a0b01..d372c0e 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/HGEntityTransferModule.cs
@@ -199,7 +199,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         public override void RemoveRegion(Scene scene)
         {
-            base.AddRegion(scene);
+            base.RemoveRegion(scene);
 
             if (m_Enabled)
                 scene.UnregisterModuleInterface<IUserAgentVerificationModule>(this);
@@ -212,11 +212,11 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         protected override GridRegion GetFinalDestination(GridRegion region)
         {
             int flags = Scene.GridService.GetRegionFlags(Scene.RegionInfo.ScopeID, region.RegionID);
-            m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: region {0} flags: {1}", region.RegionID, flags);
+            m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: region {0} flags: {1}", region.RegionName, flags);
 
             if ((flags & (int)OpenSim.Framework.RegionFlags.Hyperlink) != 0)
             {
-                m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Destination region {0} is hyperlink", region.RegionID);
+                m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: Destination region is hyperlink");
                 GridRegion real_destination = m_GatekeeperConnector.GetHyperlinkRegion(region, region.RegionID);
                 if (real_destination != null)
                     m_log.DebugFormat("[HG ENTITY TRANSFER MODULE]: GetFinalDestination serveruri -> {0}", real_destination.ServerURI);
diff --git a/OpenSim/Region/CoreModules/Framework/InterfaceCommander/Command.cs b/OpenSim/Region/CoreModules/Framework/InterfaceCommander/Command.cs
index 4004135..b9786ae 100644
--- a/OpenSim/Region/CoreModules/Framework/InterfaceCommander/Command.cs
+++ b/OpenSim/Region/CoreModules/Framework/InterfaceCommander/Command.cs
@@ -28,6 +28,7 @@
 using System;
 using System.Collections.Generic;
 using OpenSim.Region.Framework.Interfaces;
+using OpenMetaverse;
 
 namespace OpenSim.Region.CoreModules.Framework.InterfaceCommander
 {
@@ -152,6 +153,9 @@ namespace OpenSim.Region.CoreModules.Framework.InterfaceCommander
                         case "Boolean":
                             m_args[i].ArgumentValue = Boolean.Parse(arg.ToString());
                             break;
+                        case "UUID":
+                            m_args[i].ArgumentValue = UUID.Parse(arg.ToString());
+                            break;
                         default:
                             Console.WriteLine("ERROR: Unknown desired type for argument " + m_args[i].Name + " on command " + m_name);
                             break;
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGAssetMapper.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGAssetMapper.cs
index f8ec6de..7871eda 100644
--- a/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGAssetMapper.cs
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGAssetMapper.cs
@@ -71,7 +71,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
 
         #region Internal functions
 
-        public AssetMetadata FetchMetadata(string url, UUID assetID)
+        private AssetMetadata FetchMetadata(string url, UUID assetID)
         {
             if (!url.EndsWith("/") && !url.EndsWith("="))
                 url = url + "/";
@@ -86,6 +86,27 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
             return meta;
         }
 
+        private AssetBase FetchAsset(string url, UUID assetID)
+        {
+            // Test if it's already here
+            AssetBase asset = m_scene.AssetService.Get(assetID.ToString());
+            if (asset == null)
+            {
+                if (!url.EndsWith("/") && !url.EndsWith("="))
+                    url = url + "/";
+
+                asset = m_scene.AssetService.Get(url + assetID.ToString());
+
+                //if (asset != null)
+                //    m_log.DebugFormat("[HG ASSET MAPPER]: Fetched asset {0} of type {1} from {2} ", assetID, asset.Metadata.Type, url);
+                //else
+                //    m_log.DebugFormat("[HG ASSET MAPPER]: Unable to fetch asset {0} from {1} ", assetID, url);
+
+            }
+
+            return asset;
+        }
+
         public bool PostAsset(string url, AssetBase asset)
         {
             if (asset != null)
@@ -228,11 +249,22 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
             if (meta == null)
                 return;
 
-            // The act of gathering UUIDs downloads the assets from the remote server
+            // The act of gathering UUIDs downloads some assets from the remote server
+            // but not all...
             Dictionary<UUID, AssetType> ids = new Dictionary<UUID, AssetType>();
             HGUuidGatherer uuidGatherer = new HGUuidGatherer(m_scene.AssetService, userAssetURL);
             uuidGatherer.GatherAssetUuids(assetID, (AssetType)meta.Type, ids);
-
+            m_log.DebugFormat("[HG ASSET MAPPER]: Preparing to get {0} assets", ids.Count);
+            bool success = true;
+            foreach (UUID uuid in ids.Keys)
+                if (FetchAsset(userAssetURL, uuid) == null)
+                    success = false;
+
+            // maybe all pieces got here...
+            if (!success)
+                m_log.DebugFormat("[HG ASSET MAPPER]: Problems getting item {0} from asset server {1}", assetID, userAssetURL);
+            else
+                m_log.DebugFormat("[HG ASSET MAPPER]: Successfully got item {0} from asset server {1}", assetID, userAssetURL);
         }
 
 
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGInventoryAccessModule.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGInventoryAccessModule.cs
index 964efda..b2b628d 100644
--- a/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGInventoryAccessModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/HGInventoryAccessModule.cs
@@ -88,12 +88,14 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                     IConfig thisModuleConfig = source.Configs["HGInventoryAccessModule"];
                     if (thisModuleConfig != null)
                     {
-                        // legacy configuration [obsolete]
-                        m_HomeURI = thisModuleConfig.GetString("ProfileServerURI", string.Empty);
-                        // preferred
-                        m_HomeURI = thisModuleConfig.GetString("HomeURI", m_HomeURI);
+                        m_HomeURI = Util.GetConfigVarFromSections<string>(source, "HomeURI",
+                            new string[] { "Startup", "Hypergrid", "HGInventoryAccessModule" }, String.Empty);
+                        m_ThisGatekeeper = Util.GetConfigVarFromSections<string>(source, "GatekeeperURI",
+                            new string[] { "Startup", "Hypergrid", "HGInventoryAccessModule" }, String.Empty);
+                        // Legacy. Renove soon!
+                        m_ThisGatekeeper = thisModuleConfig.GetString("Gatekeeper", m_ThisGatekeeper);
+
                         m_OutboundPermission = thisModuleConfig.GetBoolean("OutboundPermission", true);
-                        m_ThisGatekeeper = thisModuleConfig.GetString("Gatekeeper", string.Empty);
                         m_RestrictInventoryAccessAbroad = thisModuleConfig.GetBoolean("RestrictInventoryAccessAbroad", true);
                     }
                     else
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
index 6e5a4a5..5aad7f0 100644
--- a/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
@@ -47,6 +47,7 @@ using OpenMetaverse;
 using log4net;
 using Nini.Config;
 using Mono.Addins;
+using PermissionMask = OpenSim.Framework.PermissionMask;
 
 namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
 {
@@ -398,7 +399,8 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                 objectGroup.RootPart.NextOwnerMask &=
                         ((uint)PermissionMask.Copy |
                          (uint)PermissionMask.Transfer |
-                         (uint)PermissionMask.Modify);
+                         (uint)PermissionMask.Modify |
+                         (uint)PermissionMask.Export);
                 objectGroup.RootPart.NextOwnerMask |=
                         (uint)PermissionMask.Move;
                 
@@ -506,7 +508,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
             InventoryItemBase item, SceneObjectGroup so, List<SceneObjectGroup> objsForEffectivePermissions, 
             IClientAPI remoteClient)
         {
-            uint effectivePerms = (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify | PermissionMask.Move) | 7;
+            uint effectivePerms = (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify | PermissionMask.Move | PermissionMask.Export) | 7;
             // For the porposes of inventory, an object is modify if the prims
             // are modify. This allows renaming an object that contains no
             // mod items.
@@ -555,6 +557,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                          (uint)PermissionMask.Transfer |
                          (uint)PermissionMask.Modify |
                          (uint)PermissionMask.Move |
+                         (uint)PermissionMask.Export |
                          7); // Preserve folded permissions
             }    
             
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/Tests/InventoryAccessModuleTests.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/Tests/InventoryAccessModuleTests.cs
index 21d8bd7..ad1a0e1 100644
--- a/OpenSim/Region/CoreModules/Framework/InventoryAccess/Tests/InventoryAccessModuleTests.cs
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/Tests/InventoryAccessModuleTests.cs
@@ -49,7 +49,7 @@ using OpenSim.Tests.Common.Mock;
 namespace OpenSim.Region.CoreModules.Framework.InventoryAccess.Tests
 {
     [TestFixture]
-    public class InventoryAccessModuleTests
+    public class InventoryAccessModuleTests : OpenSimTestCase
     {      
         protected TestScene m_scene;
         protected BasicInventoryAccessModule m_iam;
@@ -57,8 +57,10 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess.Tests
         protected TestClient m_tc;
             
         [SetUp]
-        public void SetUp()
+        public override void SetUp()
         {
+            base.SetUp();
+
             m_iam = new BasicInventoryAccessModule();
 
             IConfigSource config = new IniConfigSource();
@@ -107,7 +109,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess.Tests
             item1.AssetID = asset1.FullID;
             item1.ID = item1Id;
             InventoryFolderBase objsFolder 
-                = InventoryArchiveUtils.FindFolderByPath(m_scene.InventoryService, m_userId, "Objects")[0];
+                = InventoryArchiveUtils.FindFoldersByPath(m_scene.InventoryService, m_userId, "Objects")[0];
             item1.Folder = objsFolder.ID;
             m_scene.AddInventoryItem(item1);
             
@@ -157,7 +159,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess.Tests
             item1.AssetID = asset1.FullID;
             item1.ID = item1Id;
             InventoryFolderBase objsFolder 
-                = InventoryArchiveUtils.FindFolderByPath(m_scene.InventoryService, m_userId, "Objects")[0];
+                = InventoryArchiveUtils.FindFoldersByPath(m_scene.InventoryService, m_userId, "Objects")[0];
             item1.Folder = objsFolder.ID;
             m_scene.AddInventoryItem(item1);
             
diff --git a/OpenSim/Region/CoreModules/Framework/Library/LibraryModule.cs b/OpenSim/Region/CoreModules/Framework/Library/LibraryModule.cs
index ec22146..d07cff4 100644
--- a/OpenSim/Region/CoreModules/Framework/Library/LibraryModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/Library/LibraryModule.cs
@@ -43,6 +43,7 @@ using OpenMetaverse;
 using log4net;
 using Mono.Addins;
 using Nini.Config;
+using PermissionMask = OpenSim.Framework.PermissionMask;
 
 namespace OpenSim.Region.CoreModules.Framework.Library
 {
diff --git a/OpenSim/Region/CoreModules/Framework/Monitoring/MonitorModule.cs b/OpenSim/Region/CoreModules/Framework/Monitoring/MonitorModule.cs
index d84460a..64feec1 100644
--- a/OpenSim/Region/CoreModules/Framework/Monitoring/MonitorModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/Monitoring/MonitorModule.cs
@@ -33,6 +33,7 @@ using log4net;
 using Nini.Config;
 using OpenMetaverse;
 using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Servers;
 using OpenSim.Region.CoreModules.Framework.Monitoring.Alerts;
 using OpenSim.Region.CoreModules.Framework.Monitoring.Monitors;
@@ -100,6 +101,7 @@ namespace OpenSim.Region.CoreModules.Framework.Monitoring
                 "/monitorstats/" + Uri.EscapeDataString(m_scene.RegionInfo.RegionName), StatsPage);
 
             AddMonitors();
+            RegisterStatsManagerRegionStatistics();
         }
 
         public void RemoveRegion(Scene scene)
@@ -109,6 +111,9 @@ namespace OpenSim.Region.CoreModules.Framework.Monitoring
 
             MainServer.Instance.RemoveHTTPHandler("GET", "/monitorstats/" + m_scene.RegionInfo.RegionID);
             MainServer.Instance.RemoveHTTPHandler("GET", "/monitorstats/" + Uri.EscapeDataString(m_scene.RegionInfo.RegionName));
+
+            UnRegisterStatsManagerRegionStatistics();
+
             m_scene = null;
         }
 
@@ -399,6 +404,45 @@ namespace OpenSim.Region.CoreModules.Framework.Monitoring
         {
             m_log.Error("[Monitor] " + reporter.Name + " for " + m_scene.RegionInfo.RegionName + " reports " + reason + " (Fatal: " + fatal + ")");
         }
+
+        private List<Stat> registeredStats = new List<Stat>();
+        private void MakeStat(string pName, string pUnitName, Action<Stat> act)
+        {
+            Stat tempStat = new Stat(pName, pName, pName, pUnitName, "scene", m_scene.RegionInfo.RegionName, StatType.Pull, act, StatVerbosity.Info);
+            StatsManager.RegisterStat(tempStat);
+            registeredStats.Add(tempStat);
+        }
+        private void RegisterStatsManagerRegionStatistics()
+        {
+            MakeStat("RootAgents", "avatars", (s) => { s.Value = m_scene.SceneGraph.GetRootAgentCount(); });
+            MakeStat("ChildAgents", "avatars", (s) => { s.Value = m_scene.SceneGraph.GetChildAgentCount(); });
+            MakeStat("TotalPrims", "objects", (s) => { s.Value = m_scene.SceneGraph.GetTotalObjectsCount(); });
+            MakeStat("ActivePrims", "objects", (s) => { s.Value = m_scene.SceneGraph.GetActiveObjectsCount(); });
+            MakeStat("ActiveScripts", "scripts", (s) => { s.Value = m_scene.SceneGraph.GetActiveScriptsCount(); });
+
+            MakeStat("TimeDilation", "sec/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[0]; });
+            MakeStat("SimFPS", "fps", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[1]; });
+            MakeStat("PhysicsFPS", "fps", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[2]; });
+            MakeStat("AgentUpdates", "updates/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[3]; });
+            MakeStat("FrameTime", "ms/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[8]; });
+            MakeStat("NetTime", "ms/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[9]; });
+            MakeStat("OtherTime", "ms/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[12]; });
+            MakeStat("PhysicsTime", "ms/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[10]; });
+            MakeStat("AgentTime", "ms/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[16]; });
+            MakeStat("ImageTime", "ms/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[11]; });
+            MakeStat("ScriptLines", "lines/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[20]; });
+            MakeStat("SimSpareMS", "ms/sec", (s) => { s.Value = m_scene.StatsReporter.LastReportedSimStats[21]; });
+        }
+        
+        private void UnRegisterStatsManagerRegionStatistics()
+        {
+            foreach (Stat stat in registeredStats)
+            {
+                StatsManager.DeregisterStat(stat);
+                stat.Dispose();
+            }
+            registeredStats.Clear();
+        }
         
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Framework/Statistics/Logging/BinaryLoggingModule.cs b/OpenSim/Region/CoreModules/Framework/Statistics/Logging/BinaryLoggingModule.cs
index fb74cc6..f3436d1 100644
--- a/OpenSim/Region/CoreModules/Framework/Statistics/Logging/BinaryLoggingModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/Statistics/Logging/BinaryLoggingModule.cs
@@ -57,7 +57,7 @@ namespace OpenSim.Region.CoreModules.Framework.Statistics.Logging
             try
             {
                 IConfig statConfig = source.Configs["Statistics.Binary"];
-                if (statConfig.Contains("enabled") && statConfig.GetBoolean("enabled"))
+                if (statConfig != null && statConfig.Contains("enabled") && statConfig.GetBoolean("enabled"))
                 {
                     if (statConfig.Contains("collect_region_stats"))
                     {
diff --git a/OpenSim/Region/CoreModules/Framework/Statistics/Logging/LogWriter.cs b/OpenSim/Region/CoreModules/Framework/Statistics/Logging/LogWriter.cs
index fd8d5e3..2fe9026 100755
--- a/OpenSim/Region/CoreModules/Framework/Statistics/Logging/LogWriter.cs
+++ b/OpenSim/Region/CoreModules/Framework/Statistics/Logging/LogWriter.cs
@@ -52,6 +52,7 @@ namespace OpenSim.Region.CoreModules.Framework.Statistics.Logging
         private TimeSpan m_logFileLife;
         private DateTime m_logFileEndTime;
         private Object m_logFileWriteLock = new Object();
+        private bool m_flushWrite;
 
         // set externally when debugging. If let 'null', this does not write any error messages.
         public ILog ErrorLogger = null;
@@ -73,7 +74,9 @@ namespace OpenSim.Region.CoreModules.Framework.Statistics.Logging
         /// <param name="dir">The directory to create the log file in. May be 'null' for default.</param>
         /// <param name="headr">The characters that begin the log file name. May be 'null' for default.</param>
         /// <param name="maxFileTime">Maximum age of a log file in minutes. If zero, will set default.</param>
-        public LogWriter(string dir, string headr, int maxFileTime)
+        /// <param name="flushWrite">Whether to do a flush after every log write. Best left off but
+        /// if one is looking for a crash, this is a good thing to turn on.</param>
+        public LogWriter(string dir, string headr, int maxFileTime, bool flushWrite)
         {
             m_logDirectory = dir == null ? "." : dir;
 
@@ -86,8 +89,14 @@ namespace OpenSim.Region.CoreModules.Framework.Statistics.Logging
             m_logFileLife = new TimeSpan(0, m_logMaxFileTimeMin, 0);
             m_logFileEndTime = DateTime.Now + m_logFileLife;
 
+            m_flushWrite = flushWrite;
+
             Enabled = true;
         }
+        // Constructor that assumes flushWrite is off.
+        public LogWriter(string dir, string headr, int maxFileTime) : this(dir, headr, maxFileTime, false)
+        {
+        }
 
         public void Dispose()
         {
@@ -127,7 +136,7 @@ namespace OpenSim.Region.CoreModules.Framework.Statistics.Logging
             {
                 lock (m_logFileWriteLock)
                 {
-                    DateTime now = DateTime.Now;
+                    DateTime now = DateTime.UtcNow;
                     if (m_logFile == null || now > m_logFileEndTime)
                     {
                         if (m_logFile != null)
@@ -153,6 +162,8 @@ namespace OpenSim.Region.CoreModules.Framework.Statistics.Logging
                         buff.Append(line);
                         buff.Append("\r\n");
                         m_logFile.Write(buff.ToString());
+                        if (m_flushWrite)
+                            m_logFile.Flush();
                     }
                 }
             }
diff --git a/OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs b/OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs
index 86e7004..77e8b00 100644
--- a/OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/UserManagement/UserManagementModule.cs
@@ -181,6 +181,7 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
 
             m_log.DebugFormat("[USER MANAGEMENT MODULE]: HandleAvatarPickerRequest for {0}", query);
 
+            // searhc the user accounts service
             List<UserAccount> accs = m_Scenes[0].UserAccountService.GetUserAccounts(m_Scenes[0].RegionInfo.ScopeID, query);
 
             List<UserData> users = new List<UserData>();
@@ -196,6 +197,12 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
                 }
             }
 
+            // search the local cache
+            foreach (UserData data in m_UserCache.Values)
+                if (users.Find(delegate(UserData d) { return d.Id == data.Id; }) == null &&
+                    (data.FirstName.StartsWith(query) || data.LastName.StartsWith(query)))
+                    users.Add(data);
+
             AddAdditionalUsers(avatarID, query, users);
 
             AvatarPickerReplyPacket replyPacket = (AvatarPickerReplyPacket)PacketPool.Instance.GetPacket(PacketType.AvatarPickerReply);
@@ -433,6 +440,9 @@ namespace OpenSim.Region.CoreModules.Framework.UserManagement
         public void AddUser(UUID uuid, string first, string last, string homeURL)
         {
             //m_log.DebugFormat("[USER MANAGEMENT MODULE]: Adding user with id {0}, first {1}, last {2}, url {3}", uuid, first, last, homeURL);
+            if (homeURL == string.Empty)
+                return;
+
             AddUser(uuid, homeURL + ";" + first + " " + last);
         }