Merge branch 'master' of ssh://opensim/var/git/opensim

OpenSim/Framework/DAMap.cs

@@ -180,7 +180,7 @@ namespace OpenSim.Framework
         /// Validate the key used for storing separate data stores.
         /// </summary>
         /// <param name='key'></param>
-        private static void ValidateKey(string key)
+        public static void ValidateKey(string key)
         {
             if (key.Length < MIN_STORE_NAME_LENGTH)
                 throw new Exception("Minimum store name length is " + MIN_STORE_NAME_LENGTH);

OpenSim/Framework/DOMap.cs

@@ -0,0 +1,98 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Xml;
+using System.Xml.Schema;
+using System.Xml.Serialization;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Framework
+{
+    /// <summary>
+    /// This class stores and retrieves dynamic objects.
+    /// </summary>
+    /// <remarks>
+    /// Experimental - DO NOT USE.
+    /// </remarks>
+    public class DOMap
+    {
+        private IDictionary<string, object> m_map;
+        
+        public void Add(string key, object dynObj)
+        {
+            DAMap.ValidateKey(key);
+
+            lock (this)
+            {
+                if (m_map == null)
+                    m_map = new Dictionary<string, object>();
+
+                m_map.Add(key, dynObj);
+            }
+        }
+
+        public bool ContainsKey(string key)
+        {
+            return Get(key) != null;
+        }
+
+        /// <summary>
+        /// Get a dynamic object
+        /// </summary>
+        /// <remarks>
+        /// Not providing an index method so that users can't casually overwrite each other's objects.
+        /// </remarks>
+        /// <param name='key'></param>
+        public object Get(string key)
+        {
+            lock (this)
+            {
+                if (m_map == null)
+                    return null;
+                else
+                    return m_map[key];
+            }
+        }
+
+        public bool Remove(string key)
+        {
+            lock (this)
+            {
+                if (m_map == null)
+                    return false;
+                else
+                    return m_map.Remove(key);
+            }
+        }
+    }
+}

OpenSim/Framework/PluginManager.cs

@@ -218,7 +218,7 @@ namespace OpenSim.Framework
             Console.WriteLine ("Looking for updates...");
             Repositories.UpdateAllRepositories (ps);
             Console.WriteLine ("Available add-in updates:");
-            bool found = false;
+
             AddinRepositoryEntry[] entries = Repositories.GetAvailableUpdates();
 
             foreach (AddinRepositoryEntry entry in entries)
@@ -541,7 +541,7 @@ namespace OpenSim.Framework
 			{
             	list.AddRange(PluginRegistry.GetAddins());
 			}
-			catch(Exception e)
+			catch (Exception)
 			{
 				Addin[] x = xlist.ToArray(typeof(Addin)) as Addin[];
 				return x;

OpenSim/Framework/Util.cs

@@ -303,12 +303,12 @@ namespace OpenSim.Framework
         // Clamp the maximum magnitude of a vector
         public static Vector3 ClampV(Vector3 x, float max)
         {
-            Vector3 ret = x;
             float lenSq = x.LengthSquared();
             if (lenSq > (max * max))
             {
                 x = x / x.Length() * max;
             }
+
             return x;
         }
 

OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs

@@ -7069,7 +7069,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             if (handlerUpdatePrimFlags != null)
             {
-                byte[] data = Pack.ToBytes();
+//                byte[] data = Pack.ToBytes();
                 // 46,47,48 are special positions within the packet
                 // This may change so perhaps we need a better way
                 // of storing this (OMV.FlagUpdatePacket.UsePhysics,etc?)

OpenSim/Region/CoreModules/Framework/DynamicAttributes/DAExampleModule.cs

@@ -85,19 +85,27 @@ namespace OpenSim.Region.Framework.DynamicAttributes.DAExampleModule
         {
             OSDMap attrs = null;
             SceneObjectPart sop = m_scene.GetSceneObjectPart(groupId);
+
+            if (sop == null)
+                return true;
+
             if (!sop.DynAttrs.TryGetValue(Name, out attrs))
                 attrs = new OSDMap();
             
             OSDInteger newValue;
 
-            if (!attrs.ContainsKey("moves"))
+            // We have to lock on the entire dynamic attributes map to avoid race conditions with serialization code.
-                newValue = new OSDInteger(1);
+            lock (sop.DynAttrs)            
-            else
+            {
-                newValue = new OSDInteger(((OSDInteger)attrs["moves"]).AsInteger() + 1);
+                if (!attrs.ContainsKey("moves"))
+                    newValue = new OSDInteger(1);
+                else
+                    newValue = new OSDInteger(attrs["moves"].AsInteger() + 1);
                         
-            attrs["moves"] = newValue;
+                attrs["moves"] = newValue;
 
-            sop.DynAttrs[Name] = attrs;
+                sop.DynAttrs[Name] = attrs;
+            }
     
             m_dialogMod.SendGeneralAlert(string.Format("{0} {1} moved {2} times", sop.Name, sop.UUID, newValue));
             

OpenSim/Region/CoreModules/Framework/DynamicAttributes/DOExampleModule.cs

@@ -0,0 +1,117 @@
+/*
+ * 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.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; }
+        }
+
+ //        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)
+        {
+            so.RootPart.DynObjs.Add(Name, new MyObject());
+        }
+        
+        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;
+        }        
+    }
+}

OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs

@@ -66,6 +66,17 @@ 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; }
+
         protected bool m_Enabled = false;
 
         public Scene Scene { get; private set; }
@@ -116,6 +127,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);
                 
@@ -150,6 +164,9 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         {
             client.OnTeleportHomeRequest += TeleportHome;
             client.OnTeleportLandmarkRequest += RequestTeleportLandmark;
+
+            if (!DisableInterRegionTeleportCancellation)
+                client.OnTeleportCancel += OnClientCancelTeleport;
         }
 
         public virtual void Close() {}
@@ -168,6 +185,14 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         #region Agent Teleports
 
+        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))
@@ -519,6 +544,9 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             if (sp.ParentID != (uint)0)
                 sp.StandUp();
 
+            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);
@@ -567,6 +595,15 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 return;
             }
 
+            if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Cancelling)
+            {
+                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;
+            }
+
             // Past this point we have to attempt clean up if the teleport fails, so update transfer state.
             m_entityTransferStateMachine.UpdateInTransit(sp.UUID, AgentTransferState.Transferring);
 
@@ -631,7 +668,16 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 return;
             }
 
-            sp.ControllingClient.SendTeleportProgress(teleportFlags | (uint)TeleportFlags.DisableCancel, "sending_dest");
+            if (m_entityTransferStateMachine.GetAgentTransferState(sp.UUID) == AgentTransferState.Cancelling)
+            {
+                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);
+
+                CleanupAbortedInterRegionTeleport(sp, finalDestination);
+
+                return;
+            }
 
             m_log.DebugFormat(
                 "[ENTITY TRANSFER MODULE]: Sending new CAPS seed url {0} from {1} to {2}",
@@ -714,14 +760,19 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 //            }
         }
 
-        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 CleanupAbortedInterRegionTeleport(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);
 
@@ -729,7 +780,20 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
             // Finally, kill the agent we just created at the destination.
             Scene.SimulationService.CloseAgent(finalDestination, sp.UUID);
+        }
 
+        /// <summary>
+        /// Signal that the inter-region teleport failed and perform cleanup.
+        /// </summary>
+        /// <param name='sp'></param>
+        /// <param name='finalDestination'></param>
+        /// <param name='logout'></param>
+        protected virtual void Fail(ScenePresence sp, GridRegion finalDestination, bool logout)
+        {
+            CleanupAbortedInterRegionTeleport(sp, finalDestination);
+
+            sp.ControllingClient.SendTeleportFailed(
+                string.Format("Problems connecting to destination {0}", finalDestination.RegionName));
             sp.Scene.EventManager.TriggerTeleportFail(sp.ControllingClient, logout);
         }
 
@@ -2097,7 +2161,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)

OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs

@@ -51,8 +51,9 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
     /// This is a state machine.
     ///
     /// [Entry]               => Preparing
-    /// Preparing             => { Transferring || CleaningUp || [Exit] }
+    /// Preparing             => { Transferring || Cancelling || CleaningUp || [Exit] }
-    /// Transferring          => { ReceivedAtDestination || CleaningUp }
+    /// Transferring          => { ReceivedAtDestination || Cancelling || CleaningUp }
+    /// Cancelling            => CleaningUp
     /// ReceivedAtDestination => CleaningUp
     /// CleaningUp            => [Exit]
     ///
@@ -64,7 +65,8 @@ 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.
     }
 
     /// <summary>
@@ -115,42 +117,110 @@ 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(
+                    if (newState != AgentTransferState.Cancelling)
-                            "Agent with ID {0} is not registered as in transit in {1}",
+                        failureMessage = string.Format(
-                            id, m_mod.Scene.RegionInfo.RegionName));
+                                "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];
 
-                AgentTransferState oldState = m_agentsInTransit[id];
+                    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;
+                        }
+                    }
 
-                bool transitionOkay = false;
+                    if (!transitionOkay)
-
+                        failureMessage 
-                if (newState == AgentTransferState.CleaningUp && oldState != AgentTransferState.CleaningUp)
+                            = string.Format(
-                    transitionOkay = true;
+                                "Agent with ID {0} is not allowed to move from old transit state {1} to new state {2} in {3}",
-                else if (newState == AgentTransferState.Transferring && oldState == AgentTransferState.Preparing)
+                                id, oldState, newState, m_mod.Scene.RegionInfo.RegionName);
-                    transitionOkay = true;
+                }
-                else if (newState == AgentTransferState.ReceivedAtDestination && oldState == AgentTransferState.Transferring)
-                    transitionOkay = true;
 
                 if (transitionOkay)
+                {
                     m_agentsInTransit[id] = newState;
-                else
+
-                    throw new Exception(
+//                    m_log.DebugFormat(
-                        string.Format(
+//                        "[ENTITY TRANSFER STATE MACHINE]: Changed agent with id {0} from state {1} to {2} in {3}", 
-                            "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.Name);
-                            id, oldState, newState, m_mod.Scene.RegionInfo.RegionName));
+                }
+                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 +273,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(

OpenSim/Region/CoreModules/Scripting/VectorRender/VectorRenderModule.cs

@@ -516,6 +516,9 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
                 foreach (string line in GetLines(data, dataDelim))
                 {
                     string nextLine = line.Trim();
+
+//                    m_log.DebugFormat("[VECTOR RENDER MODULE]: Processing line '{0}'", nextLine);
+
                     //replace with switch, or even better, do some proper parsing
                     if (nextLine.StartsWith("MoveTo"))
                     {
@@ -829,6 +832,8 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
                     float y = Convert.ToSingle(yVal, CultureInfo.InvariantCulture);
                     PointF point = new PointF(x, y);
                     points[i / 2] = point;
+
+//                    m_log.DebugFormat("[VECTOR RENDER MODULE]: Got point {0}", points[i / 2]);
                 }
             }
         }

OpenSim/Region/Framework/Scenes/SceneObjectPart.cs

@@ -130,6 +130,27 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public DAMap DynAttrs { get; set; }
 
+        private DOMap m_dynObjs;
+
+        /// <summary>
+        /// Dynamic objects that can be created and deleted as required.
+        /// </summary>
+        public DOMap DynObjs 
+        { 
+            get
+            {
+                if (m_dynObjs == null)
+                    m_dynObjs = new DOMap();
+
+                return m_dynObjs;
+            }
+
+            set
+            {
+                m_dynObjs = value;
+            }
+        }
+        
         /// <value>
         /// Is this a root part?
         /// </value>

OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs

@@ -662,13 +662,18 @@ namespace SecondLife
                 {
                     string severity = CompErr.IsWarning ? "Warning" : "Error";
 
-                    KeyValuePair<int, int> lslPos;
+                    KeyValuePair<int, int> errorPos;
 
                     // Show 5 errors max, but check entire list for errors
 
                     if (severity == "Error")
                     {
-                        lslPos = FindErrorPosition(CompErr.Line, CompErr.Column, m_lineMaps[assembly]);
+                        // C# scripts will not have a linemap since theres no line translation involved.
+                        if (!m_lineMaps.ContainsKey(assembly))
+                            errorPos = new KeyValuePair<int, int>(CompErr.Line, CompErr.Column);
+                        else
+                            errorPos = FindErrorPosition(CompErr.Line, CompErr.Column, m_lineMaps[assembly]);
+
                         string text = CompErr.ErrorText;
 
                         // Use LSL type names
@@ -678,7 +683,7 @@ namespace SecondLife
                         // The Second Life viewer's script editor begins
                         // countingn lines and columns at 0, so we subtract 1.
                         errtext += String.Format("({0},{1}): {4} {2}: {3}\n",
-                                lslPos.Key - 1, lslPos.Value - 1,
+                                errorPos.Key - 1, errorPos.Value - 1,
                                 CompErr.ErrorNumber, text, severity);
                         hadErrors = true;
                     }

bin/OpenSim.ini.example

@@ -541,6 +541,13 @@
     ; shout_distance = 100
 
 
+[EntityTransfer]
+    ;# {DisableInterRegionTeleportCancellation} {} {Determine whether the cancel button is shown at all during teleports.} {false true} false
+    ;; This option exists because cancelling at certain points can result in an unuseable session (frozen avatar, etc.)
+    ;; Disabling cancellation can be okay in small closed grids where all teleports are highly likely to suceed.
+    ;DisableInterRegionTeleportCancellation = false
+
+
 [Messaging]
     ;# {OfflineMessageModule} {} {Module to use for offline message storage} {OfflineMessageModule "Offline Message Module V2" *}
     ;; Module to handle offline messaging. The core module requires an external

bin/OpenSimDefaults.ini

@@ -628,6 +628,11 @@
     ; Minimum user level required for HyperGrid teleports
     LevelHGTeleport = 0
 
+    ; Determine whether the cancel button is shown at all during teleports.
+    ; This option exists because cancelling at certain points can result in an unuseable session (frozen avatar, etc.)
+    ; Disabling cancellation can be okay in small closed grids where all teleports are highly likely to suceed.
+    DisableInterRegionTeleportCancellation = false
+
 
 [Messaging]
     ; Control which region module is used for instant messaging.