44 files changed, 2891 insertions, 1033 deletions
diff --git a/OpenSim/Region/Framework/Interfaces/IBakedTextureModule.cs b/OpenSim/Region/Framework/Interfaces/IBakedTextureModule.cs
index 21ed44f..b536a49 100644
--- a/OpenSim/Region/Framework/Interfaces/IBakedTextureModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IBakedTextureModule.cs
@@ -1,9 +1,30 @@
-////////////////////////////////////////////////////////////////
+/*
-//
+ * Copyright (c) Contributors, http://opensimulator.org/
-// (c) 2009, 2010 Careminster Limited and Melanie Thielker
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
-//
+ *
-// All rights reserved
+ * 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 Nini.Config;
 using OpenSim.Framework;
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
index 8028d87..eba881f 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
@@ -236,15 +236,17 @@ namespace OpenSim.Region.Framework.Interfaces
        List<TaskInventoryItem> GetInventoryItems(InventoryType type);
        /// <summary>
-        /// Get the scene object referenced by an inventory item.
+        /// Get the scene object(s) referenced by an inventory item.
        /// </summary>
        /// 
        /// This is returned in a 'rez ready' state.  That is, name, description, permissions and other details have
        /// been adjusted to reflect the part and item from which it originates.
        /// 
-        /// <param name="item"></param>
+        /// <param name="item">Inventory item</param>
-        /// <returns>The scene object.  Null if the scene object asset couldn't be found</returns>
+        /// <param name="objlist">The scene objects</param>
-        SceneObjectGroup GetRezReadySceneObject(TaskInventoryItem item);
+        /// <param name="veclist">Relative offsets for each object</param>
+        /// <returns>true = success, false = the scene object asset couldn't be found</returns>
+        bool GetRezReadySceneObjects(TaskInventoryItem item, out List<SceneObjectGroup> objlist, out List<Vector3> veclist);
        /// <summary>
        /// Update an existing inventory item.
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs b/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
index 1949a90..214b07a 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
@@ -47,13 +47,33 @@ namespace OpenSim.Region.Framework.Interfaces
        /// The handle of the destination region.  If it's the same as the region currently
        /// occupied by the agent then the teleport will be within that region.
        /// </param>
+        /// <param name='agent'></param>
+        /// <param name='regionHandle'></param>
        /// <param name='position'></param>
        /// <param name='lookAt'></param>
        /// <param name='teleportFlags'></param>
        void Teleport(ScenePresence agent, ulong regionHandle, Vector3 position, Vector3 lookAt, uint teleportFlags);
+        /// <summary>
+        /// Teleports the agent for the given client to their home destination.
+        /// </summary>
+        /// <param name='id'></param>
+        /// <param name='client'></param>
        bool TeleportHome(UUID id, IClientAPI client);
+        /// <summary>
+        /// Teleport an agent directly to a given region without checking whether the region should be substituted.
+        /// </summary>
+        /// <remarks>
+        /// Please use Teleport() instead unless you know exactly what you're doing.
+        /// Do not use for same region teleports.
+        /// </remarks>
+        /// <param name='sp'></param>
+        /// <param name='reg'></param>
+        /// <param name='finalDestination'>/param>
+        /// <param name='position'></param>
+        /// <param name='lookAt'></param>
+        /// <param name='teleportFlags'></param>
        void DoTeleport(ScenePresence sp, GridRegion reg, GridRegion finalDestination,
            Vector3 position, Vector3 lookAt, uint teleportFlags);
diff --git a/OpenSim/Region/Framework/Interfaces/IEstateModule.cs b/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
index 292efa4..944c66b 100644
--- a/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
@@ -40,7 +40,7 @@ namespace OpenSim.Region.Framework.Interfaces
        uint GetRegionFlags();
        bool IsManager(UUID avatarID);
-        
        /// <summary>
        /// Tell all clients about the current state of the region (terrain textures, water height, etc.).
        /// </summary>
@@ -54,5 +54,10 @@ namespace OpenSim.Region.Framework.Interfaces
        void setEstateTerrainBaseTexture(int level, UUID texture);
        void setEstateTerrainTextureHeights(int corner, float lowValue, float highValue);
+        /// <summary>
+        /// Returns whether the transfer ID is being used for a terrain transfer.
+        /// </summary>
+        bool IsTerrainXfer(ulong xferID);
    }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/IEventQueue.cs b/OpenSim/Region/Framework/Interfaces/IEventQueue.cs
index 5512642..dfc269e 100644
--- a/OpenSim/Region/Framework/Interfaces/IEventQueue.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEventQueue.cs
@@ -39,21 +39,22 @@ namespace OpenSim.Region.Framework.Interfaces
        // These are required to decouple Scenes from EventQueueHelper
        void DisableSimulator(ulong handle, UUID avatarID);
-        void EnableSimulator(ulong handle, IPEndPoint endPoint, UUID avatarID);
+        void EnableSimulator(ulong handle, IPEndPoint endPoint, UUID avatarID, int regionSizeX, int regionSizeY);
        void EstablishAgentCommunication(UUID avatarID, IPEndPoint endPoint, 
-                                         string capsPath);
+                                         string capsPath, ulong regionHandle, int regionSizeX, int regionSizeY);
        void TeleportFinishEvent(ulong regionHandle, byte simAccess, 
                                 IPEndPoint regionExternalEndPoint,
                                 uint locationID, uint flags, string capsURL, 
-                                 UUID agentID);
+                                 UUID agentID, int regionSizeX, int regionSizeY);
        void CrossRegion(ulong handle, Vector3 pos, Vector3 lookAt,
                         IPEndPoint newRegionExternalEndPoint,
-                         string capsURL, UUID avatarID, UUID sessionID);
+                         string capsURL, UUID avatarID, UUID sessionID,
+                            int regionSizeX, int regionSizeY);
        void ChatterboxInvitation(UUID sessionID, string sessionName,
                                  UUID fromAgent, string message, UUID toAgent, string fromName, byte dialog,
                                  uint timeStamp, bool offline, int parentEstateID, Vector3 position,
                                  uint ttl, UUID transactionID, bool fromGroup, byte[] binaryBucket);
-        void ChatterBoxSessionAgentListUpdates(UUID sessionID, UUID fromAgent, UUID toAgent, bool canVoiceChat, 
+        void ChatterBoxSessionAgentListUpdates(UUID sessionID, UUID fromAgent, UUID anotherAgent, bool canVoiceChat, 
                                               bool isModerator, bool textMute);
        void ParcelProperties(ParcelPropertiesMessage parcelPropertiesMessage, UUID avatarID);
        void GroupMembership(AgentGroupDataUpdatePacket groupUpdate, UUID avatarID);
diff --git a/OpenSim/Region/Framework/Interfaces/IExternalCapsModule.cs b/OpenSim/Region/Framework/Interfaces/IExternalCapsModule.cs
new file mode 100644
index 0000000..a730cfd
--- /dev/null
+++ b/OpenSim/Region/Framework/Interfaces/IExternalCapsModule.cs
@@ -0,0 +1,48 @@
+/*
+ * 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 OpenMetaverse;
+using OpenSim.Framework;
+using Caps=OpenSim.Framework.Capabilities.Caps;
+namespace OpenSim.Region.Framework.Interfaces
+{
+    public interface IExternalCapsModule
+    {
+        /// <summary>
+        /// This function extends the simple URL configuration in the caps handlers
+        /// to facilitate more interesting computation when an external handler is
+        /// sent to the viewer. 
+        /// </summary>
+        /// <param name="agentID">New user UUID</param>
+        /// <param name="caps">Internal caps registry, where the external handler will be registered</param>
+        /// <param name="capName">Name of the specific cap we are registering</param>
+        /// <param name="urlSkel">The skeleton URL provided in the caps configuration</param>
+        bool RegisterExternalUserCapsHandler(UUID agentID, Caps caps, String capName, String urlSkel);
+    }
+}
diff --git a/OpenSim/Region/Framework/Interfaces/IGroupsModule.cs b/OpenSim/Region/Framework/Interfaces/IGroupsModule.cs
index 6885327..9ae5e87 100644
--- a/OpenSim/Region/Framework/Interfaces/IGroupsModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IGroupsModule.cs
@@ -97,5 +97,7 @@ namespace OpenSim.Region.Framework.Interfaces
        void InviteGroupRequest(IClientAPI remoteClient, UUID GroupID, UUID InviteeID, UUID RoleID);
        void InviteGroup(IClientAPI remoteClient, UUID agentID, UUID GroupID, UUID InviteeID, UUID RoleID);
        void NotifyChange(UUID GroupID);
+        List<DirGroupsReplyData> FindGroups(IClientAPI remoteClient, string query);
    }
 }
 \ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IInterregionComms.cs b/OpenSim/Region/Framework/Interfaces/IInterregionComms.cs
deleted file mode 100644
index 67a500f..0000000
--- a/OpenSim/Region/Framework/Interfaces/IInterregionComms.cs
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * 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 OpenMetaverse;
-using OpenSim.Framework;
-using OpenSim.Region.Framework.Scenes;
-namespace OpenSim.Region.Framework.Interfaces
-{
-    public delegate bool ChildAgentUpdateReceived(AgentData data);
-    public interface IInterregionCommsOut
-    {
-        #region Agents
-        bool SendCreateChildAgent(ulong regionHandle, AgentCircuitData aCircuit, uint teleportFlags, out string reason);
-        /// <summary>
-        /// Full child agent update.
-        /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="data"></param>
-        /// <returns></returns>
-        bool SendChildAgentUpdate(ulong regionHandle, AgentData data);
-        /// <summary>
-        /// Short child agent update, mostly for position.
-        /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="data"></param>
-        /// <returns></returns>
-        bool SendChildAgentUpdate(ulong regionHandle, AgentPosition data);
-        bool SendRetrieveRootAgent(ulong regionHandle, UUID id, out IAgentData agent);
-        /// <summary>
-        /// Message from receiving region to departing region, telling it got contacted by the client.
-        /// When sent over REST, it invokes the opaque uri.
-        /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="id"></param>
-        /// <param name="uri"></param>
-        /// <returns></returns>
-        bool SendReleaseAgent(ulong regionHandle, UUID id, string uri);
-        /// <summary>
-        /// Close chid agent.
-        /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        bool SendCloseChildAgent(ulong regionHandle, UUID id);
-        /// <summary>
-        /// Close agent.
-        /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        bool SendCloseAgent(ulong regionHandle, UUID id);
-        #endregion Agents
-        #region Objects
-        /// <summary>
-        /// Create an object in the destination region. This message is used primarily for prim crossing.
-        /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="sog"></param>
-        /// <param name="isLocalCall"></param>
-        /// <returns></returns>
-        bool SendCreateObject(ulong regionHandle, SceneObjectGroup sog, bool isLocalCall);
-        /// <summary>
-        /// Create an object from the user's inventory in the destination region. 
-        /// This message is used primarily by clients.
-        /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="userID"></param>
-        /// <param name="itemID"></param>
-        /// <returns></returns>
-        bool SendCreateObject(ulong regionHandle, UUID userID, UUID itemID);
-        #endregion Objects
-    }
-    // This may not be needed, but having it here for now.
-    public interface IInterregionCommsIn
-    {
-        event ChildAgentUpdateReceived OnChildAgentUpdate;
-    }
-}
diff --git a/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs b/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
index b67312e..1a89721 100644
--- a/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
@@ -51,10 +51,17 @@ namespace OpenSim.Region.Framework.Interfaces
        UUID = 5
    }
    
+    public struct JsonStoreStats
+    {
+        public int StoreCount;
+    }
    public delegate void TakeValueCallback(string s);
    public interface IJsonStoreModule
    {
+        JsonStoreStats GetStoreStats();
        bool AttachObjectStore(UUID objectID);
        bool CreateStore(string value, ref UUID result);
        bool DestroyStore(UUID storeID);
diff --git a/OpenSim/Region/Framework/Interfaces/IServiceThrottleModule.cs b/OpenSim/Region/Framework/Interfaces/IServiceThrottleModule.cs
new file mode 100644
index 0000000..198256f
--- /dev/null
+++ b/OpenSim/Region/Framework/Interfaces/IServiceThrottleModule.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+namespace OpenSim.Region.Framework.Interfaces
+{
+    public interface IServiceThrottleModule
+    {
+        /// <summary>
+        /// Enqueue a continuation meant to get a resource from elsewhere.
+        /// As usual with CPS, caller beware: if that continuation is a never-ending computation,
+        /// the whole thread will be blocked, and no requests are processed
+        /// </summary>
+        /// <param name="category">Category of the resource (e.g. name, region)</param>
+        /// <param name="itemid">The resource identifier</param>
+        /// <param name="continuation">The continuation to be executed</param>
+        void Enqueue(string category, string itemid, Action continuation);
+    }
+}
diff --git a/OpenSim/Region/Framework/Interfaces/ISoundModule.cs b/OpenSim/Region/Framework/Interfaces/ISoundModule.cs
index 68af492..8372ddd 100644
--- a/OpenSim/Region/Framework/Interfaces/ISoundModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/ISoundModule.cs
@@ -104,7 +104,6 @@ namespace OpenSim.Region.Framework.Interfaces
        /// <param name="sound">Sound asset ID</param>
        /// <param name="volume">Sound volume</param>
        /// <param name="triggered">Triggered or not.</param>
-        /// <param name="flags"></param>
        /// <param name="radius">Sound radius</param>
        /// <param name="useMaster">Play using sound master</param>
        /// <param name="isMaster">Play as sound master</param>
@@ -123,5 +122,12 @@ namespace OpenSim.Region.Framework.Interfaces
        /// <param name="max">AABB top north-east corner</param>
        void TriggerSoundLimited(UUID objectID, UUID sound, double volume,
                Vector3 min, Vector3 max);
+        /// <summary>
+        /// Set whether sounds on the given prim should be queued.
+        /// </summary>
+        /// <param name='objectID'></param>
+        /// <param name='shouldQueue'></param>
+        void SetSoundQueueing(UUID objectID, bool shouldQueue);
    }
 }
 \ No newline at end of file
diff --git a/OpenSim/Region/Framework/Properties/AssemblyInfo.cs b/OpenSim/Region/Framework/Properties/AssemblyInfo.cs
index 167c248..a2a99d4 100644
--- a/OpenSim/Region/Framework/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/Framework/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@ using System.Runtime.InteropServices;
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.7.6.*")]
+[assembly: AssemblyVersion("0.8.0.*")]
diff --git a/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs b/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
index 66edfed..b7400ea 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
@@ -28,8 +28,11 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Text;
 using log4net;
 using OpenMetaverse;
+using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using Animation = OpenSim.Framework.Animation;
@@ -60,6 +63,12 @@ namespace OpenSim.Region.Framework.Scenes.Animation
            ResetDefaultAnimation();
        }
+        public AnimationSet(OSDArray pArray)
+        {
+            ResetDefaultAnimation();
+            FromOSDArray(pArray);
+        }
        public bool HasAnimation(UUID animID)
        {
            if (m_defaultAnimation.AnimID == animID)
@@ -218,5 +227,110 @@ namespace OpenSim.Region.Framework.Scenes.Animation
            foreach (OpenSim.Framework.Animation anim in theArray)
                m_animations.Add(anim);
        }
+        // Create representation of this AnimationSet as an OSDArray.
+        // First two entries in the array are the default and implicitDefault animations
+        //    followed by the other animations.
+        public OSDArray ToOSDArray()
+        {
+            OSDArray ret = new OSDArray();
+            ret.Add(DefaultAnimation.PackUpdateMessage());
+            ret.Add(ImplicitDefaultAnimation.PackUpdateMessage());
+            foreach (OpenSim.Framework.Animation anim in m_animations)
+                ret.Add(anim.PackUpdateMessage());
+            return ret;
+        }
+        public void FromOSDArray(OSDArray pArray)
+        {
+            this.Clear();
+            if (pArray.Count >= 1)
+            {
+                m_defaultAnimation = new OpenSim.Framework.Animation((OSDMap)pArray[0]);
+            }
+            if (pArray.Count >= 2)
+            {
+                m_implicitDefaultAnimation = new OpenSim.Framework.Animation((OSDMap)pArray[1]);
+            }
+            for (int ii = 2; ii < pArray.Count; ii++)
+            {
+                m_animations.Add(new OpenSim.Framework.Animation((OSDMap)pArray[ii]));
+            }
+        }
+        // Compare two AnimationSets and return 'true' if the default animations are the same
+        //     and all of the animations in the list are equal.
+        public override bool Equals(object obj)
+        {
+            AnimationSet other = obj as AnimationSet;
+            if (other != null)
+            {
+                if (this.DefaultAnimation.Equals(other.DefaultAnimation)
+                    && this.ImplicitDefaultAnimation.Equals(other.ImplicitDefaultAnimation))
+                {
+                    // The defaults are the same. Is the list of animations the same?
+                    OpenSim.Framework.Animation[] thisAnims = this.ToArray();
+                    OpenSim.Framework.Animation[] otherAnims = other.ToArray();
+                    if (thisAnims.Length == 0 && otherAnims.Length == 0)
+                        return true;    // the common case
+                    if (thisAnims.Length == otherAnims.Length)
+                    {
+                        // Do this the hard way but since the list is usually short this won't take long.
+                        foreach (OpenSim.Framework.Animation thisAnim in thisAnims)
+                        {
+                            bool found = false;
+                            foreach (OpenSim.Framework.Animation otherAnim in otherAnims)
+                            {
+                                if (thisAnim.Equals(otherAnim))
+                                {
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            if (!found)
+                            {
+                                // If anything is not in the other list, these are not equal
+                                return false;
+                            }
+                        }
+                        // Found everything in the other list. Since lists are equal length, they must be equal.
+                        return true;
+                    }
+                }
+                return false;
+            }
+            // Don't know what was passed, but the base system will figure it out for me.
+            return base.Equals(obj);
+        }
+        public override string ToString()
+        {
+            StringBuilder buff = new StringBuilder();
+            buff.Append("dflt=");
+            buff.Append(DefaultAnimation.ToString());
+            buff.Append(",iDflt=");
+            if (DefaultAnimation.Equals(ImplicitDefaultAnimation))
+                buff.Append("same");
+            else
+                buff.Append(ImplicitDefaultAnimation.ToString());
+            if (m_animations.Count > 0)
+            {
+                buff.Append(",anims=");
+                bool firstTime = true;
+                foreach (OpenSim.Framework.Animation anim in m_animations)
+                {
+                    if (!firstTime)
+                        buff.Append(",");
+                    buff.Append("<");
+                    buff.Append(anim.ToString());
+                    buff.Append(">");
+                    firstTime = false;
+                }
+            }
+            return buff.ToString();
+        }
    }
 }
diff --git a/OpenSim/Region/Framework/Scenes/Animation/DefaultAvatarAnimations.cs b/OpenSim/Region/Framework/Scenes/Animation/DefaultAvatarAnimations.cs
index c2b0468..b79dd8f 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/DefaultAvatarAnimations.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/DefaultAvatarAnimations.cs
@@ -104,5 +104,31 @@ namespace OpenSim.Region.Framework.Scenes.Animation
            return UUID.Zero;
        }
+        /// <summary>
+        /// Get the name of the animation given a UUID. If there is no matching animation
+        ///    return the UUID as a string.
+        /// </summary>
+        public static string GetDefaultAnimationName(UUID uuid)
+        {
+            string ret = "unknown";
+            if (AnimsUUID.ContainsValue(uuid))
+            {
+                foreach (KeyValuePair<string, UUID> kvp in AnimsUUID)
+                {
+                    if (kvp.Value == uuid)
+                    {
+                        ret = kvp.Key;
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                ret = uuid.ToString();
+            }
+            return ret;
+        }
    }
 }
 \ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
index 65c279e..c1394aa 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/ScenePresenceAnimator.cs
@@ -93,7 +93,10 @@ namespace OpenSim.Region.Framework.Scenes.Animation
                    GetAnimName(animID), animID, m_scenePresence.Name);
            if (m_animations.Add(animID, m_scenePresence.ControllingClient.NextAnimationSequenceNumber, objectID))
+            {
                SendAnimPack();
+                m_scenePresence.TriggerScenePresenceUpdated();
+            }
        }
        // Called from scripts
@@ -132,7 +135,10 @@ namespace OpenSim.Region.Framework.Scenes.Animation
                    GetAnimName(animID), animID, m_scenePresence.Name);
            if (m_animations.Remove(animID, allowNoDefault))
+            {
                SendAnimPack();
+                m_scenePresence.TriggerScenePresenceUpdated();
+            }
        }
        public void avnChangeAnim(UUID animID, bool addRemove, bool sendPack)
@@ -180,8 +186,10 @@ namespace OpenSim.Region.Framework.Scenes.Animation
        /// The movement animation is reserved for "main" animations
        /// that are mutually exclusive, e.g. flying and sitting.
        /// </summary>
-        public void TrySetMovementAnimation(string anim)
+        /// <returns>'true' if the animation was updated</returns>
+        public bool TrySetMovementAnimation(string anim)
        {
+            bool ret = false;
            if (!m_scenePresence.IsChildAgent)
            {
 //                m_log.DebugFormat(
@@ -198,6 +206,7 @@ namespace OpenSim.Region.Framework.Scenes.Animation
                    // 16384 is CHANGED_ANIMATION
                    m_scenePresence.SendScriptEventToAttachments("changed", new Object[] { (int)Changed.ANIMATION});
                    SendAnimPack();
+                    ret = true;
                }
            }
            else
@@ -206,6 +215,7 @@ namespace OpenSim.Region.Framework.Scenes.Animation
                    "[SCENE PRESENCE ANIMATOR]: Tried to set movement animation {0} on child presence {1}",
                    anim, m_scenePresence.Name);
            }
+            return ret;
        }
        /// <summary>
@@ -410,11 +420,18 @@ namespace OpenSim.Region.Framework.Scenes.Animation
                Falling = false;
                // Walking / crouchwalking / running
                if (move.Z < 0f)
+                {
                    return "CROUCHWALK";
-                else if (m_scenePresence.SetAlwaysRun)
+                }
-                    return "RUN";
+                // We need to prevent these animations if the user tries to make their avatar walk or run whilst
-                else
+                // specifying AGENT_CONTROL_STOP (pressing down space on viewers).
-                    return "WALK";
+                else if (!m_scenePresence.AgentControlStopActive)
+                {
+                    if (m_scenePresence.SetAlwaysRun)
+                        return "RUN";
+                    else
+                        return "WALK";
+                }
            }
            else if (!m_jumping)
            {
@@ -439,8 +456,12 @@ namespace OpenSim.Region.Framework.Scenes.Animation
        /// <summary>
        /// Update the movement animation of this avatar according to its current state
        /// </summary>
-        public void UpdateMovementAnimations()
+        /// <returns>'true' if the animation was changed</returns>
+        public bool UpdateMovementAnimations()
        {
+//            m_log.DebugFormat("[SCENE PRESENCE ANIMATOR]: Updating movement animations for {0}", m_scenePresence.Name);
+            bool ret = false;
            lock (m_animations)
            {
                string newMovementAnimation = DetermineMovementAnimation();
@@ -454,9 +475,10 @@ namespace OpenSim.Region.Framework.Scenes.Animation
                    // Only set it if it's actually changed, give a script
                    // a chance to stop a default animation
-                    TrySetMovementAnimation(CurrentMovementAnimation);
+                    ret = TrySetMovementAnimation(CurrentMovementAnimation);
                }
            }
+            return ret;
        }
        public UUID[] GetAnimationArray()
diff --git a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
index f555b49..11a0146 100644
--- a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
+++ b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
@@ -104,14 +104,8 @@ namespace OpenSim.Region.Framework.Scenes
            // better than losing the object for now.
            if (permissionToDelete)
            {
-                List<uint> killIDs = new List<uint>();
                foreach (SceneObjectGroup g in objectGroups)
-                {   killIDs.Add(g.LocalId);
+                    g.DeleteGroupFromScene(false);
-                    g.DeleteGroupFromScene(true);
-                }
-                m_scene.SendKillObject(killIDs);
            }
        }
        
@@ -160,7 +154,7 @@ namespace OpenSim.Region.Framework.Scenes
                            if (x.permissionToDelete)
                            {
                                foreach (SceneObjectGroup g in x.objectGroups)
-                                    m_scene.DeleteSceneObject(g, false);
+                                    m_scene.DeleteSceneObject(g, true);
                            }
                        }
                        catch (Exception e)
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 4733547..7f06e82 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -148,7 +148,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// Triggered when a new presence is added to the scene
        /// </summary>
        /// <remarks>
-        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewClient"/> which is used by both
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewAgent"/> which is used by both
        /// <see cref="OpenSim.Framework.PresenceType.User">users</see> and <see cref="OpenSim.Framework.PresenceType.Npc">NPCs</see>
        /// </remarks>
        public event OnNewPresenceDelegate OnNewPresence;
@@ -159,7 +159,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// Triggered when a presence is removed from the scene
        /// </summary>
        /// <remarks>
-        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewClient"/> which is used by both
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewAgent"/> which is used by both
        /// <see cref="OpenSim.Framework.PresenceType.User">users</see> and <see cref="OpenSim.Framework.PresenceType.Npc">NPCs</see>
        /// 
        /// Triggered under per-agent lock.  So if you want to perform any long-running operations, please
@@ -743,7 +743,7 @@ namespace OpenSim.Region.Framework.Scenes
        public event OnIncomingSceneObjectDelegate OnIncomingSceneObject;
        public delegate void OnIncomingSceneObjectDelegate(SceneObjectGroup so);
-        public delegate void NewInventoryItemUploadComplete(UUID avatarID, UUID assetID, string name, int userlevel);
+        public delegate void NewInventoryItemUploadComplete(UUID avatarID, AssetType type, UUID assetID, string name, int userlevel);
        public event NewInventoryItemUploadComplete OnNewInventoryItemUploadComplete;
@@ -974,6 +974,8 @@ namespace OpenSim.Region.Framework.Scenes
        public delegate void RegionStarted(Scene scene);
        public event RegionStarted OnRegionStarted;
+        public delegate void RegionHeartbeatStart(Scene scene);
+        public event RegionHeartbeatStart OnRegionHeartbeatStart;
        public delegate void RegionHeartbeatEnd(Scene scene);
        public event RegionHeartbeatEnd OnRegionHeartbeatEnd;
@@ -1024,6 +1026,16 @@ namespace OpenSim.Region.Framework.Scenes
        /// </remarks>
        public event TeleportFail OnTeleportFail;
+//        public delegate void GatherUuids(SceneObjectPart sop, IDictionary<UUID, AssetType> assetUuids);
+//
+//        /// <summary>
+//        /// Triggered when UUIDs referenced by a scene object are being gathered for archiving, hg transfer, etc.
+//        /// </summary>
+//        /// <remarks>
+//        /// The listener should add references to the IDictionary<UUID, AssetType> as appropriate.
+//        /// </remarks>
+//        public event GatherUuids OnGatherUuids;
        public class MoneyTransferArgs : EventArgs
        {
            public UUID sender;
@@ -1095,7 +1107,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.ProcessMoneyTransferRequest"/>
        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.SubscribeToClientGridEvents"/>
        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.SubscribeToClientEvents"/>
-        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewClient"/>
+        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewAgent"/>
        /// </remarks>
        public event MoneyTransferEvent OnMoneyTransfer;
@@ -2160,7 +2172,7 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
-        public void TriggerOnNewInventoryItemUploadComplete(UUID agentID, UUID AssetID, String AssetName, int userlevel)
+        public void TriggerOnNewInventoryItemUploadComplete(UUID agentID, AssetType type, UUID AssetID, String AssetName, int userlevel)
        {
            NewInventoryItemUploadComplete handlerNewInventoryItemUpdateComplete = OnNewInventoryItemUploadComplete;
            if (handlerNewInventoryItemUpdateComplete != null)
@@ -2169,7 +2181,7 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    try
                    {
-                        d(agentID, AssetID, AssetName, userlevel);
+                        d(agentID, type, AssetID, AssetName, userlevel);
                    }
                    catch (Exception e)
                    {
@@ -3096,6 +3108,27 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
+        public void TriggerRegionHeartbeatStart(Scene scene)
+        {
+            RegionHeartbeatStart handler = OnRegionHeartbeatStart;
+            if (handler != null)
+            {
+                foreach (RegionHeartbeatStart d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(scene);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("[EVENT MANAGER]: Delegate for OnRegionHeartbeatStart failed - continuing {0} - {1}",
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }
        public void TriggerRegionHeartbeatEnd(Scene scene)
        {
            RegionHeartbeatEnd handler = OnRegionHeartbeatEnd;
@@ -3251,5 +3284,26 @@ namespace OpenSim.Region.Framework.Scenes
                handler(scenePresence);
            }
        }
+//        public void TriggerGatherUuids(SceneObjectPart sop, IDictionary<UUID, AssetType> assetUuids)
+//        {
+//            GatherUuids handler = OnGatherUuids;
+//
+//            if (handler != null)
+//            {
+//                foreach (GatherUuids d in handler.GetInvocationList())
+//                {
+//                    try
+//                    {
+//                        d(sop, assetUuids);
+//                    }
+//                    catch (Exception e)
+//                    {
+//                        m_log.ErrorFormat("[EVENT MANAGER]: Delegate for TriggerUuidGather failed - continuing {0} - {1}",
+//                            e.Message, e.StackTrace);
+//                    }
+//                }
+//            }
+//        }
    }
 }
diff --git a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
index f0e639d..49b71e5 100644
--- a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
+++ b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
@@ -1,6 +1,29 @@
-// Proprietary code of Avination Virtual Limited
+/*
-// (c) 2012 Melanie Thielker
+ * 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.Timers;
@@ -32,7 +55,6 @@ namespace OpenSim.Region.Framework.Scenes
        private object m_lockObject = new object();
        private object m_timerLock = new object();
        private const double m_tickDuration = 50.0;
-        private Scene m_scene;
        public double TickDuration
        {
@@ -46,8 +68,6 @@ namespace OpenSim.Region.Framework.Scenes
            m_timer.AutoReset = true;
            m_timer.Elapsed += OnTimer;
-            m_scene = scene;
            m_timer.Start();
        }
@@ -71,13 +91,13 @@ namespace OpenSim.Region.Framework.Scenes
                    {
                        m.OnTimer(TickDuration);
                    }
-                    catch (Exception inner)
+                    catch (Exception)
                    {
                        // Don't stop processing
                    }
                }
            }
-            catch (Exception e)
+            catch (Exception)
            {
                // Keep running no matter what
            }
@@ -134,7 +154,7 @@ namespace OpenSim.Region.Framework.Scenes
    [Serializable]
    public class KeyframeMotion
    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        public enum PlayMode : int
        {
@@ -500,6 +520,7 @@ namespace OpenSim.Region.Framework.Scenes
                        k.Position = pos;
 //                        k.Velocity = Vector3.Zero;
                    }
+                    k.AngularVelocity = (Vector3)k.Position;
                    k.StartRotation = rot;
                    if (k.Rotation.HasValue)
@@ -668,7 +689,7 @@ namespace OpenSim.Region.Framework.Scenes
                m_group.RootPart.Velocity = Vector3.Zero;
                m_group.RootPart.AngularVelocity = Vector3.Zero;
-                m_nextPosition = (Vector3)m_currentFrame.Position;
+                m_nextPosition = NormalizeVector(m_currentFrame.AngularVelocity);
                m_group.AbsolutePosition = m_nextPosition;
                // we are sending imediate updates, no doing force a extra terseUpdate
@@ -755,7 +776,26 @@ namespace OpenSim.Region.Framework.Scenes
                m_group.SendGroupRootTerseUpdate();
            }
        }
+        private Vector3 NormalizeVector(Vector3? pPosition)
+        {
+            if (pPosition == null)
+                return Vector3.Zero;
+            Vector3 tmp = (Vector3) pPosition;
+            while (tmp.X > Constants.RegionSize)
+                tmp.X -= Constants.RegionSize;
+            while (tmp.X < 0)
+                tmp.X += Constants.RegionSize;
+            while (tmp.Y > Constants.RegionSize)
+                tmp.Y -= Constants.RegionSize;
+            while (tmp.Y < 0)
+                tmp.Y += Constants.RegionSize;
+            return tmp;
+            
+        }
        public Byte[] Serialize()
        {
            StopTimer();
diff --git a/OpenSim/Region/Framework/Scenes/RegionStatsHandler.cs b/OpenSim/Region/Framework/Scenes/RegionStatsHandler.cs
index c11174d..f208afb 100644
--- a/OpenSim/Region/Framework/Scenes/RegionStatsHandler.cs
+++ b/OpenSim/Region/Framework/Scenes/RegionStatsHandler.cs
@@ -46,47 +46,33 @@ using OpenSim.Region.Framework.Scenes;
 namespace OpenSim.Region.Framework.Scenes
 {
-    public class RegionStatsHandler : IStreamedRequestHandler
+    public class RegionStatsHandler : BaseStreamHandler
    {
        //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        private string osRXStatsURI = String.Empty;
        private string osXStatsURI = String.Empty;
        //private string osSecret = String.Empty;
        private OpenSim.Framework.RegionInfo regionInfo;
        public string localZone = TimeZone.CurrentTimeZone.StandardName;
        public TimeSpan utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now);
-        public string Name { get { return "RegionStats"; } }
+        public RegionStatsHandler(RegionInfo region_info) 
-        public string Description { get { return "Region Statistics"; } }
+            : base("GET", "/" + Util.SHA1Hash(region_info.regionSecret), "RegionStats", "Region Statistics")
-        public RegionStatsHandler(RegionInfo region_info)
        {
            regionInfo = region_info;
-            osRXStatsURI = Util.SHA1Hash(regionInfo.regionSecret);
            osXStatsURI = Util.SHA1Hash(regionInfo.osSecret);
        }
                    
-        public byte[] Handle(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        protected override byte[] ProcessRequest(
+            string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
        {
            return Util.UTF8.GetBytes(Report());
        }
-        public string ContentType
+        public override string ContentType
        {
            get { return "text/plain"; }
        }
-        public string HttpMethod
-        {
-            get { return "GET"; }
-        }
-        public string Path
-        {
-            // This is for the region and is the regionSecret hashed
-            get { return "/" + osRXStatsURI; }
-        }
        
        private string Report()
        {
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index d2e41f8..d87091c 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -31,6 +31,7 @@ using System.Collections;
 using System.Reflection;
 using System.Text;
 using System.Timers;
+using System.Xml;
 using OpenMetaverse;
 using OpenMetaverse.Packets;
 using log4net;
@@ -139,7 +140,7 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    userlevel = 1;
                }
-                EventManager.TriggerOnNewInventoryItemUploadComplete(item.Owner, item.AssetID, item.Name, userlevel);
+                EventManager.TriggerOnNewInventoryItemUploadComplete(item.Owner, (AssetType)item.AssetType, item.AssetID, item.Name, userlevel);
                return true;
            }
@@ -178,7 +179,7 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    userlevel = 1;
                }
-                EventManager.TriggerOnNewInventoryItemUploadComplete(item.Owner, item.AssetID, item.Name, userlevel);
+                EventManager.TriggerOnNewInventoryItemUploadComplete(item.Owner, (AssetType)item.AssetType, item.AssetID, item.Name, userlevel);
                if (originalFolder != UUID.Zero)
                {
@@ -411,19 +412,21 @@ namespace OpenSim.Region.Framework.Scenes
 //                        itemUpd.NextPermissions, itemUpd.GroupPermissions, itemUpd.EveryOnePermissions, item.Flags,
 //                        item.NextPermissions, item.GroupPermissions, item.EveryOnePermissions, item.CurrentPermissions);
+                bool sendUpdate = false;
                if (itemUpd.NextPermissions != 0) // Use this to determine validity. Can never be 0 if valid
                {
                    // Create a set of base permissions that will not include export if the user
                    // is not allowed to change the export flag.
                    bool denyExportChange = false;
-                    m_log.InfoFormat("[XXX]: B: {0} O: {1} E: {2}", itemUpd.BasePermissions, itemUpd.CurrentPermissions, itemUpd.EveryOnePermissions);
+//                    m_log.DebugFormat("[XXX]: B: {0} O: {1} E: {2}", itemUpd.BasePermissions, itemUpd.CurrentPermissions, itemUpd.EveryOnePermissions);
                    // If the user is not the creator or doesn't have "E" in both "B" and "O", deny setting export
                    if ((item.BasePermissions & (uint)(PermissionMask.All | PermissionMask.Export)) != (uint)(PermissionMask.All | PermissionMask.Export) || (item.CurrentPermissions & (uint)PermissionMask.Export) == 0 || item.CreatorIdAsUuid != item.Owner)
                        denyExportChange = true;
-                    m_log.InfoFormat("[XXX]: Deny Export Update {0}", denyExportChange);
+//                    m_log.DebugFormat("[XXX]: Deny Export Update {0}", denyExportChange);
                    // If it is already set, force it set and also force full perm
                    // else prevent setting it. It can and should never be set unless
@@ -447,7 +450,7 @@ namespace OpenSim.Region.Framework.Scenes
                        // If the new state is exportable, force full perm
                        if ((itemUpd.EveryOnePermissions & (uint)PermissionMask.Export) != 0)
                        {
-                            m_log.InfoFormat("[XXX]: Force full perm");
+//                            m_log.DebugFormat("[XXX]: Force full perm");
                            itemUpd.NextPermissions = (uint)(PermissionMask.All);
                        }
                    }
@@ -484,8 +487,13 @@ namespace OpenSim.Region.Framework.Scenes
                    item.SalePrice = itemUpd.SalePrice;
                    item.SaleType = itemUpd.SaleType;
+                    if (item.InvType == (int)InventoryType.Wearable && (item.Flags & 0xf) == 0 && (itemUpd.Flags & 0xf) != 0)
+                    {
+                        item.Flags = (uint)(item.Flags & 0xfffffff0) | (itemUpd.Flags & 0xf);
+                        sendUpdate = true;
+                    }
                    InventoryService.UpdateItem(item);
-                    remoteClient.SendBulkUpdateInventory(item);
                }
                if (UUID.Zero != transactionID)
@@ -495,6 +503,17 @@ namespace OpenSim.Region.Framework.Scenes
                        AgentTransactionsModule.HandleItemUpdateFromTransaction(remoteClient, transactionID, item);
                    }
                }
+                else
+                {
+                    // This MAY be problematic, if it is, another solution
+                    // needs to be found. If inventory item flags are updated
+                    // the viewer's notion of the item needs to be refreshed.
+                    //
+                    // In other situations we cannot send out a bulk update here, since this will cause editing of clothing to start 
+                    // failing frequently.  Possibly this is a race with a separate transaction that uploads the asset.
+                    if (sendUpdate)
+                        remoteClient.SendBulkUpdateInventory(item);
+                }
            }
            else
            {
@@ -548,6 +567,9 @@ namespace OpenSim.Region.Framework.Scenes
        {
            //Console.WriteLine("Scene.Inventory.cs: GiveInventoryItem");
+            if (!Permissions.CanTransferUserInventory(itemId, senderId, recipient))
+                return null;
            InventoryItemBase item = new InventoryItemBase(itemId, senderId);
            item = InventoryService.GetItem(item);
@@ -642,17 +664,13 @@ namespace OpenSim.Region.Framework.Scenes
                // a mask
                if (item.InvType == (int)InventoryType.Object)
                {
-                    // Create a safe mask for the current perms
-                    uint foldedPerms = (item.CurrentPermissions & 7) << 13;
-                    foldedPerms |= permsMask;
                    bool isRootMod = (item.CurrentPermissions &
                                      (uint)PermissionMask.Modify) != 0 ?
                                      true : false;
                    // Mask the owner perms to the folded perms
-                    ownerPerms &= foldedPerms;
+                    PermissionsUtil.ApplyFoldedPermissions(item.CurrentPermissions, ref ownerPerms);
-                    basePerms &= foldedPerms;
+                    PermissionsUtil.ApplyFoldedPermissions(item.CurrentPermissions, ref basePerms);
                    // If the root was mod, let the mask reflect that
                    // We also need to adjust the base here, because
@@ -1213,9 +1231,16 @@ namespace OpenSim.Region.Framework.Scenes
            {
                agentItem.BasePermissions = taskItem.BasePermissions & (taskItem.NextPermissions | (uint)PermissionMask.Move);
                if (taskItem.InvType == (int)InventoryType.Object)
-                    agentItem.CurrentPermissions = agentItem.BasePermissions & (((taskItem.CurrentPermissions & 7) << 13) | (taskItem.CurrentPermissions & (uint)PermissionMask.Move));
+                {
+                    uint perms = taskItem.CurrentPermissions;
+                    PermissionsUtil.ApplyFoldedPermissions(taskItem.CurrentPermissions, ref perms);
+                    agentItem.BasePermissions = perms | (uint)PermissionMask.Move;
+                    agentItem.CurrentPermissions = agentItem.BasePermissions;
+                }
                else
+                {
                    agentItem.CurrentPermissions = agentItem.BasePermissions & taskItem.CurrentPermissions;
+                }
                agentItem.Flags |= (uint)InventoryItemFlags.ObjectSlamPerm;
                agentItem.NextPermissions = taskItem.NextPermissions;
@@ -2124,7 +2149,10 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    // If we don't have permission, stop right here
                    if (!permissionToTakeCopy)
+                    {
+                        remoteClient.SendAlertMessage("You don't have permission to take the object");
                        return;
+                    }
                    permissionToTake = true;
                    // Don't delete
@@ -2277,6 +2305,87 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
+        /// Returns the list of Scene Objects in an asset.
+        /// </summary>
+        /// <remarks>
+        /// Returns one object if the asset is a regular object, and multiple objects for a coalesced object.
+        /// </remarks>
+        /// <param name="assetData">Asset data</param>
+        /// <param name="attachment">Whether the item is an attachment</param>
+        /// <param name="objlist">The objects included in the asset</param>
+        /// <param name="veclist">Relative positions of the objects</param>
+        /// <param name="bbox">Bounding box of all the objects</param>
+        /// <param name="offsetHeight">Offset in the Z axis from the centre of the bounding box
+        /// to the centre of the root prim (relevant only when returning a single object)</param>
+        /// <returns>true = returning a single object; false = multiple objects</returns>
+        public bool GetObjectsToRez(byte[] assetData, bool attachment, out List<SceneObjectGroup> objlist, out List<Vector3> veclist,
+            out Vector3 bbox, out float offsetHeight)
+        {
+            objlist = new List<SceneObjectGroup>();
+            veclist = new List<Vector3>();
+            XmlDocument doc = new XmlDocument();
+            string xmlData = Utils.BytesToString(assetData);
+            doc.LoadXml(xmlData);
+            XmlElement e = (XmlElement)doc.SelectSingleNode("/CoalescedObject");
+            if (e == null || attachment) // Single
+            {
+                SceneObjectGroup g = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
+                if (!attachment)
+                {
+                    g.RootPart.AttachPoint = g.RootPart.Shape.State;
+                    g.RootPart.AttachOffset = g.AbsolutePosition;
+                    g.RootPart.AttachRotation = g.GroupRotation;
+                    if (g.RootPart.Shape.PCode != (byte)PCode.NewTree &&
+                        g.RootPart.Shape.PCode != (byte)PCode.Tree)
+                        g.RootPart.Shape.State = 0;
+                }
+                objlist.Add(g);
+                veclist.Add(new Vector3(0, 0, 0));
+                bbox = g.GetAxisAlignedBoundingBox(out offsetHeight);
+                return true;
+            }
+            else
+            {
+                XmlElement coll = (XmlElement)e;
+                float bx = Convert.ToSingle(coll.GetAttribute("x"));
+                float by = Convert.ToSingle(coll.GetAttribute("y"));
+                float bz = Convert.ToSingle(coll.GetAttribute("z"));
+                bbox = new Vector3(bx, by, bz);
+                offsetHeight = 0;
+                XmlNodeList groups = e.SelectNodes("SceneObjectGroup");
+                foreach (XmlNode n in groups)
+                {
+                    SceneObjectGroup g = SceneObjectSerializer.FromOriginalXmlFormat(n.OuterXml);
+                    g.RootPart.AttachPoint = g.RootPart.Shape.State;
+                    g.RootPart.AttachOffset = g.AbsolutePosition;
+                    g.RootPart.AttachRotation = g.GroupRotation;
+                    if (g.RootPart.Shape.PCode != (byte)PCode.NewTree &&
+                        g.RootPart.Shape.PCode != (byte)PCode.Tree)
+                    g.RootPart.Shape.State = 0;
+                    objlist.Add(g);
+                    XmlElement el = (XmlElement)n;
+                    string rawX = el.GetAttribute("offsetx");
+                    string rawY = el.GetAttribute("offsety");
+                    string rawZ = el.GetAttribute("offsetz");
+                    float x = Convert.ToSingle(rawX);
+                    float y = Convert.ToSingle(rawY);
+                    float z = Convert.ToSingle(rawZ);
+                    veclist.Add(new Vector3(x, y, z));
+                }
+            }
+            return false;
+        }
+        /// <summary>
        /// Event Handler Rez an object into a scene
        /// Calls the non-void event handler
        /// </summary>
@@ -2351,19 +2460,25 @@ namespace OpenSim.Region.Framework.Scenes
        /// will be used if it exists.</param>
        /// <param name="vel">The velocity of the rezzed object.</param>
        /// <param name="param"></param>
-        /// <returns>The SceneObjectGroup rezzed or null if rez was unsuccessful</returns>
+        /// <returns>The SceneObjectGroup(s) rezzed, or null if rez was unsuccessful</returns>
-        public virtual SceneObjectGroup RezObject(
+        public virtual List<SceneObjectGroup> RezObject(
            SceneObjectPart sourcePart, TaskInventoryItem item, Vector3 pos, Quaternion? rot, Vector3 vel, int param)
        {
            if (null == item)
                return null;
+            List<SceneObjectGroup> objlist;
+            List<Vector3> veclist;
            
-            SceneObjectGroup group = sourcePart.Inventory.GetRezReadySceneObject(item);
+            bool success = sourcePart.Inventory.GetRezReadySceneObjects(item, out objlist, out veclist);
-            
+            if (!success)
-            if (null == group)
                return null;
-            
-            if (!Permissions.CanRezObject(group.PrimCount, item.OwnerID, pos))
+            int totalPrims = 0;
+            foreach (SceneObjectGroup group in objlist)
+                totalPrims += group.PrimCount;
+            if (!Permissions.CanRezObject(totalPrims, item.OwnerID, pos))
                return null;
            if (!Permissions.BypassPermissions())
@@ -2372,16 +2487,28 @@ namespace OpenSim.Region.Framework.Scenes
                    sourcePart.Inventory.RemoveInventoryItem(item.ItemID);
            }
-            group.FromPartID = sourcePart.UUID;
+            for (int i = 0; i < objlist.Count; i++)
-            AddNewSceneObject(group, true, pos, rot, vel);
+            {
-            
+                SceneObjectGroup group = objlist[i];
-            // We can only call this after adding the scene object, since the scene object references the scene
+                Vector3 curpos = pos + veclist[i];
-            // to find out if scripts should be activated at all.
-            group.CreateScriptInstances(param, true, DefaultScriptEngine, 3);
+                if (group.IsAttachment == false && group.RootPart.Shape.State != 0)
-            
+                {
-            group.ScheduleGroupForFullUpdate();
+                    group.RootPart.AttachedPos = group.AbsolutePosition;
-        
+                    group.RootPart.Shape.LastAttachPoint = (byte)group.AttachmentPoint;
-            return group;
+                }
+                group.FromPartID = sourcePart.UUID;
+                AddNewSceneObject(group, true, curpos, rot, vel);
+                // We can only call this after adding the scene object, since the scene object references the scene
+                // to find out if scripts should be activated at all.
+                group.CreateScriptInstances(param, true, DefaultScriptEngine, 3);
+                group.ScheduleGroupForFullUpdate();
+            }
+            return objlist;
        }
        public virtual bool returnObjects(SceneObjectGroup[] returnobjects,
diff --git a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
index ce6415a..46b2d2e 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
@@ -252,8 +252,6 @@ namespace OpenSim.Region.Framework.Scenes
            if (part.ParentGroup.RootPart.LocalId != part.LocalId)
                return;
-            bool isAttachment = false;
-            
            // This is wrong, wrong, wrong. Selection should not be
            // handled by group, but by prim. Legacy cruft.
            // TODO: Make selection flagging per prim!
@@ -262,17 +260,14 @@ namespace OpenSim.Region.Framework.Scenes
                || Permissions.CanMoveObject(part.ParentGroup.UUID, remoteClient.AgentId))
                part.ParentGroup.IsSelected = false;
            
-            if (part.ParentGroup.IsAttachment)
+            part.ParentGroup.ScheduleGroupForFullUpdate();
-                isAttachment = true;
-            else
-                part.ParentGroup.ScheduleGroupForFullUpdate();
            // If it's not an attachment, and we are allowed to move it,
            // then we might have done so. If we moved across a parcel
            // boundary, we will need to recount prims on the parcels.
            // For attachments, that makes no sense.
            //
-            if (!isAttachment)
+            if (!part.ParentGroup.IsAttachment)
            {
                if (Permissions.CanEditObject(
                        part.UUID, remoteClient.AgentId) 
@@ -416,6 +411,7 @@ namespace OpenSim.Region.Framework.Scenes
        void ProcessViewerEffect(IClientAPI remoteClient, List<ViewerEffectEventHandlerArg> args)
        {
            // TODO: don't create new blocks if recycling an old packet
+            bool discardableEffects = true;
            ViewerEffectPacket.EffectBlock[] effectBlockArray = new ViewerEffectPacket.EffectBlock[args.Count];
            for (int i = 0; i < args.Count; i++)
            {
@@ -427,17 +423,34 @@ namespace OpenSim.Region.Framework.Scenes
                effect.Type = args[i].Type;
                effect.TypeData = args[i].TypeData;
                effectBlockArray[i] = effect;
+                if ((EffectType)effect.Type != EffectType.LookAt && (EffectType)effect.Type != EffectType.Beam)
+                    discardableEffects = false;
+                //m_log.DebugFormat("[YYY]: VE {0} {1} {2}", effect.AgentID, effect.Duration, (EffectType)effect.Type);
            }
-            ForEachClient(
+            ForEachScenePresence(sp =>
-                delegate(IClientAPI client)
                {
-                    if (client.AgentId != remoteClient.AgentId)
+                    if (sp.ControllingClient.AgentId != remoteClient.AgentId)
-                        client.SendViewerEffect(effectBlockArray);
+                    {
-                }
+                        if (!discardableEffects ||
-            );
+                            (discardableEffects && ShouldSendDiscardableEffect(remoteClient, sp)))
+                        {
+                            //m_log.DebugFormat("[YYY]: Sending to {0}", sp.UUID);
+                            sp.ControllingClient.SendViewerEffect(effectBlockArray);
+                        }
+                        //else
+                        //    m_log.DebugFormat("[YYY]: Not sending to {0}", sp.UUID);
+                    }
+                });
        }
        
+        private bool ShouldSendDiscardableEffect(IClientAPI thisClient, ScenePresence other)
+        {
+            return Vector3.Distance(other.CameraPosition, thisClient.SceneAgent.AbsolutePosition) < 10;
+        }
        private class DescendentsRequestData
        {
            public IClientAPI RemoteClient;
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index b189599..55766cf 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -151,7 +151,7 @@ namespace OpenSim.Region.Framework.Scenes
        public SynchronizeSceneHandler SynchronizeScene;
        /// <summary>
-        /// Used to prevent simultaneous calls to RemoveClient() for the same agent from interfering with each other.
+        /// Used to prevent simultaneous calls to code that adds and removes agents.
        /// </summary>
        private object m_removeClientLock = new object();
@@ -230,6 +230,8 @@ namespace OpenSim.Region.Framework.Scenes
        public bool m_seeIntoBannedRegion = false;
        public int MaxUndoCount = 5;
+        public bool SeeIntoRegion { get; set; }
        // Using this for RegionReady module to prevent LoginsDisabled from changing under our feet;
        public bool LoginLock = false;
@@ -396,10 +398,12 @@ namespace OpenSim.Region.Framework.Scenes
                if (value)
                {
                    if (!m_active)
-                        Start();
+                        Start(false);
                }
                else
                {
+                    // This appears assymetric with Start() above but is not - setting m_active = false stops the loops
+                    // XXX: Possibly this should be in an explicit Stop() method for symmetry.
                    m_active = false;
                }
            }
@@ -747,6 +751,7 @@ namespace OpenSim.Region.Framework.Scenes
            m_config = config;
            MinFrameTime = 0.089f;
            MinMaintenanceTime = 1;
+            SeeIntoRegion = true;
            Random random = new Random();
@@ -859,9 +864,12 @@ namespace OpenSim.Region.Framework.Scenes
                //Animation states
                m_useFlySlow = startupConfig.GetBoolean("enableflyslow", false);
+                SeeIntoRegion = startupConfig.GetBoolean("see_into_region", SeeIntoRegion);
+                MaxUndoCount = startupConfig.GetInt("MaxPrimUndos", 20);
                PhysicalPrims = startupConfig.GetBoolean("physical_prim", true);
                CollidablePrims = startupConfig.GetBoolean("collidable_prim", true);
                m_minNonphys = startupConfig.GetFloat("NonPhysicalPrimMin", m_minNonphys);
                if (RegionInfo.NonphysPrimMin > 0)
                {
@@ -1332,7 +1340,7 @@ namespace OpenSim.Region.Framework.Scenes
            Thread.Sleep(500);
            // Stop all client threads.
-            ForEachScenePresence(delegate(ScenePresence avatar) { avatar.ControllingClient.Close(); });
+            ForEachScenePresence(delegate(ScenePresence avatar) { CloseAgent(avatar.UUID, false); });
            m_log.Debug("[SCENE]: TriggerSceneShuttingDown");
            EventManager.TriggerSceneShuttingDown(this);
@@ -1361,10 +1369,18 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
+        public override void Start()
+        {
+            Start(true);
+        }
        /// <summary>
        /// Start the scene
        /// </summary>
-        public void Start()
+        /// <param name='startScripts'>
+        /// Start the scripts within the scene.
+        /// </param> 
+        public void Start(bool startScripts)
        {
            m_active = true;
@@ -1401,6 +1417,8 @@ namespace OpenSim.Region.Framework.Scenes
            m_heartbeatThread
                = Watchdog.StartThread(
                    Heartbeat, string.Format("Heartbeat ({0})", RegionInfo.RegionName), ThreadPriority.Normal, false, false);
+            StartScripts();
        }
        /// <summary>
@@ -1557,6 +1575,8 @@ namespace OpenSim.Region.Framework.Scenes
                try
                {
+                    EventManager.TriggerRegionHeartbeatStart(this);
                    // Apply taints in terrain module to terrain in physics scene
                    if (Frame % m_update_terrain == 0)
                    {
@@ -1996,6 +2016,11 @@ namespace OpenSim.Region.Framework.Scenes
            GridRegion region = new GridRegion(RegionInfo);
            string error = GridService.RegisterRegion(RegionInfo.ScopeID, region);
+            m_log.DebugFormat("{0} RegisterRegionWithGrid. name={1},id={2},loc=<{3},{4}>,size=<{5},{6}>",
+                                LogHeader, m_regionName, 
+                                RegionInfo.RegionID,
+                                RegionInfo.RegionLocX, RegionInfo.RegionLocY,
+                                RegionInfo.RegionSizeX, RegionInfo.RegionSizeY);
            if (error != String.Empty)
                throw new Exception(error);
        }
@@ -2935,14 +2960,15 @@ namespace OpenSim.Region.Framework.Scenes
        #region Add/Remove Avatar Methods
-        public override ISceneAgent AddNewClient(IClientAPI client, PresenceType type)
+        public override ISceneAgent AddNewAgent(IClientAPI client, PresenceType type)
        {
            ScenePresence sp;
            bool vialogin;
+            bool reallyNew = true;
            // Validation occurs in LLUDPServer
            //
-            // XXX: A race condition exists here where two simultaneous calls to AddNewClient can interfere with
+            // XXX: A race condition exists here where two simultaneous calls to AddNewAgent can interfere with
            // each other.  In practice, this does not currently occur in the code.
            AgentCircuitData aCircuit = m_authenticateHandler.GetAgentCircuitData(client.CircuitCode);
@@ -2950,9 +2976,9 @@ namespace OpenSim.Region.Framework.Scenes
            // and a simultaneous one that removes it (as can happen if the client is closed at a particular point
            // whilst connecting).
            //
-            // It would be easier to lock across all NewUserConnection(), AddNewClient() and
+            // It would be easier to lock across all NewUserConnection(), AddNewAgent() and
            // RemoveClient() calls for all agents, but this would allow a slow call (e.g. because of slow service
-            // response in some module listening to AddNewClient()) from holding up unrelated agent calls.
+            // response in some module listening to AddNewAgent()) from holding up unrelated agent calls.
            //
            // In practice, the lock (this) in LLUDPServer.AddNewClient() currently lock across all
            // AddNewClient() operations (though not other ops).
@@ -2969,7 +2995,7 @@ namespace OpenSim.Region.Framework.Scenes
                // XXX: Not sure how good it is to add a new client if a scene presence already exists.  Possibly this
                // could occur if a viewer crashes and relogs before the old client is kicked out.  But this could cause
-                // other problems, and possible the code calling AddNewClient() should ensure that no client is already
+                // other problems, and possibly the code calling AddNewAgent() should ensure that no client is already
                // connected.
                if (sp == null)
                {
@@ -2997,16 +3023,24 @@ namespace OpenSim.Region.Framework.Scenes
                    m_log.WarnFormat(
                        "[SCENE]: Already found {0} scene presence for {1} in {2} when asked to add new scene presence",
                        sp.IsChildAgent ? "child" : "root", sp.Name, RegionInfo.RegionName);
+                    reallyNew = false;
                }
    
                // We must set this here so that TriggerOnNewClient and TriggerOnClientLogin can determine whether the
                // client is for a root or child agent.
+                // XXX: This may be better set for a new client before that client is added to the client manager.
+                // But need to know what happens in the case where a ScenePresence is already present (and if this 
+                // actually occurs).
                client.SceneAgent = sp;
-                // Cache the user's name
+                // This is currently also being done earlier in NewUserConnection for real users to see if this 
+                // resolves problems where HG agents are occasionally seen by others as "Unknown user" in chat and other
+                // places.  However, we still need to do it here for NPCs.
                CacheUserName(sp, aCircuit);
    
-                EventManager.TriggerOnNewClient(client);
+                if (reallyNew)
+                    EventManager.TriggerOnNewClient(client);
+    
                if (vialogin)
                    EventManager.TriggerOnClientLogin(client);
            }
@@ -3027,7 +3061,7 @@ namespace OpenSim.Region.Framework.Scenes
            {
                string first = aCircuit.firstname, last = aCircuit.lastname;
-                if (sp.PresenceType == PresenceType.Npc)
+                if (sp != null && sp.PresenceType == PresenceType.Npc)
                {
                    UserManagementModule.AddUser(aCircuit.AgentID, first, last);
                }
@@ -3105,7 +3139,8 @@ namespace OpenSim.Region.Framework.Scenes
                        if (sp != null)
                        {
                            PresenceService.LogoutAgent(sp.ControllingClient.SessionId);
-                            sp.ControllingClient.Close();
+                            CloseAgent(sp.UUID, false);
                        }
                        // BANG! SLASH!
@@ -3244,8 +3279,6 @@ namespace OpenSim.Region.Framework.Scenes
        {
            //client.OnNameFromUUIDRequest += HandleUUIDNameRequest;
            client.OnMoneyTransferRequest += ProcessMoneyTransferRequest;
-            client.OnSetStartLocationRequest += SetHomeRezPoint;
-            client.OnRegionHandleRequest += RegionHandleRequest;
        }
        
        public virtual void SubscribeToClientNetworkEvents(IClientAPI client)
@@ -3371,8 +3404,6 @@ namespace OpenSim.Region.Framework.Scenes
        {
            //client.OnNameFromUUIDRequest -= HandleUUIDNameRequest;
            client.OnMoneyTransferRequest -= ProcessMoneyTransferRequest;
-            client.OnSetStartLocationRequest -= SetHomeRezPoint;
-            client.OnRegionHandleRequest -= RegionHandleRequest;
        }
        public virtual void UnSubscribeToClientNetworkEvents(IClientAPI client)
@@ -3498,33 +3529,6 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// Sets the Home Point.   The LoginService uses this to know where to put a user when they log-in
-        /// </summary>
-        /// <param name="remoteClient"></param>
-        /// <param name="regionHandle"></param>
-        /// <param name="position"></param>
-        /// <param name="lookAt"></param>
-        /// <param name="flags"></param>
-        public virtual void SetHomeRezPoint(IClientAPI remoteClient, ulong regionHandle, Vector3 position, Vector3 lookAt, uint flags)
-        {
-            //Add half the avatar's height so that the user doesn't fall through prims
-            ScenePresence presence;
-            if (TryGetScenePresence(remoteClient.AgentId, out presence))
-            {
-                if (presence.Appearance != null)
-                {
-                    position.Z = position.Z + (presence.Appearance.AvatarHeight / 2);
-                }
-            }
-            if (GridUserService != null && GridUserService.SetHome(remoteClient.AgentId.ToString(), RegionInfo.RegionID, position, lookAt))
-                // FUBAR ALERT: this needs to be "Home position set." so the viewer saves a home-screenshot.
-                m_dialogModule.SendAlertToUser(remoteClient, "Home position set.");
-            else
-                m_dialogModule.SendAlertToUser(remoteClient, "Set Home request Failed.");
-        }
-        /// <summary>
        /// Get the avatar apperance for the given client.
        /// </summary>
        /// <param name="client"></param>
@@ -3548,63 +3552,69 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
-        public override void RemoveClient(UUID agentID, bool closeChildAgents)
+        /// <summary>
+        /// Remove the given client from the scene. 
+        /// </summary>
+        /// <remarks>
+        /// Only clientstack code should call this directly.  All other code should call IncomingCloseAgent() instead
+        /// to properly operate the state machine and avoid race conditions with other close requests (such as directly
+        /// from viewers).
+        /// </remarks>
+        /// <param name='agentID'>ID of agent to close</param>
+        /// <param name='closeChildAgents'>
+        /// Close the neighbour child agents associated with this client.
+        /// </param>
+        public void RemoveClient(UUID agentID, bool closeChildAgents)
        {
-//            CheckHeartbeat();
+            AgentCircuitData acd = m_authenticateHandler.GetAgentCircuitData(agentID);
-            bool isChildAgent = false;
-            AgentCircuitData acd;
-            lock (m_removeClientLock)
+            // Shouldn't be necessary since RemoveClient() is currently only called by IClientAPI.Close() which 
+            // in turn is only called by Scene.IncomingCloseAgent() which checks whether the presence exists or not
+            // However, will keep for now just in case.
+            if (acd == null)
            {
-                acd = m_authenticateHandler.GetAgentCircuitData(agentID);
+                m_log.ErrorFormat(
+                    "[SCENE]: No agent circuit found for {0} in {1}, aborting Scene.RemoveClient", agentID, Name);
-                if (acd == null)
+                return;
-                {
+            }
-                    m_log.ErrorFormat("[SCENE]: No agent circuit found for {0}, aborting Scene.RemoveClient", agentID);
+            else
-                    return;
+            {
-                }
+                m_authenticateHandler.RemoveCircuit(agentID);
-                else
-                {
-                    // We remove the acd up here to avoid later race conditions if two RemoveClient() calls occurred
-                    // simultaneously.
-                    // We also need to remove by agent ID since NPCs will have no circuit code.
-                    m_authenticateHandler.RemoveCircuit(agentID);
-                }
            }
+            // TODO: Can we now remove this lock?
            lock (acd)
-            {
+            {    
+                bool isChildAgent = false;
                ScenePresence avatar = GetScenePresence(agentID);
-    
+ 
+                // Shouldn't be necessary since RemoveClient() is currently only called by IClientAPI.Close() which 
+                // in turn is only called by Scene.IncomingCloseAgent() which checks whether the presence exists or not
+                // However, will keep for now just in case.
                if (avatar == null)
                {
-                    m_log.WarnFormat(
+                    m_log.ErrorFormat(
                        "[SCENE]: Called RemoveClient() with agent ID {0} but no such presence is in the scene.", agentID);
    
                    return;
                }
-    
                try
                {
                    isChildAgent = avatar.IsChildAgent;
                    m_log.DebugFormat(
                        "[SCENE]: Removing {0} agent {1} {2} from {3}",
-                        (isChildAgent ? "child" : "root"), avatar.Name, agentID, RegionInfo.RegionName);
+                        isChildAgent ? "child" : "root", avatar.Name, agentID, Name);
    
                    // Don't do this to root agents, it's not nice for the viewer
                    if (closeChildAgents && isChildAgent)
                    {
                        // Tell a single agent to disconnect from the region.
-                        IEventQueue eq = RequestModuleInterface<IEventQueue>();
+                        // Let's do this via UDP
-                        if (eq != null)
+                        avatar.ControllingClient.SendShutdownConnectionNotice();
-                        {
-                            eq.DisableSimulator(RegionInfo.RegionHandle, avatar.UUID);
-                        }
-                        else
-                        {
-                            avatar.ControllingClient.SendShutdownConnectionNotice();
-                        }
                    }
    
                    // Only applies to root agents.
@@ -3620,16 +3630,13 @@ namespace OpenSim.Region.Framework.Scenes
                    if (closeChildAgents && CapsModule != null)
                        CapsModule.RemoveCaps(agentID, avatar.ControllingClient.CircuitCode);
    
-//                    // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
-//                    // this method is doing is HORRIBLE!!!
-                    // Commented pending deletion since this method no longer appears to do anything at all
-//                    avatar.Scene.NeedSceneCacheClear(avatar.UUID);
-    
                    if (closeChildAgents && !isChildAgent)
                    {
                        List<ulong> regions = avatar.KnownRegionHandles;
                        regions.Remove(RegionInfo.RegionHandle);
-                        m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
+                        // This ends up being done asynchronously so that a logout isn't held up where there are many present but unresponsive neighbours.
+                        m_sceneGridService.SendCloseChildAgentConnections(agentID, acd.SessionID.ToString(), regions);
                    }
    
                    m_eventManager.TriggerClientClosed(agentID, this);
@@ -3646,7 +3653,7 @@ namespace OpenSim.Region.Framework.Scenes
                            delegate(IClientAPI client)
                            {
                                //We can safely ignore null reference exceptions.  It means the avatar is dead and cleaned up anyway
-                                try { client.SendKillObject(avatar.RegionHandle, new List<uint> { avatar.LocalId }); }
+                                try { client.SendKillObject(new List<uint> { avatar.LocalId }); }
                                catch (NullReferenceException) { }
                            });
                    }
@@ -3727,7 +3734,8 @@ namespace OpenSim.Region.Framework.Scenes
                }
                deleteIDs.Add(localID);
            }
-            ForEachClient(delegate(IClientAPI client) { client.SendKillObject(m_regionHandle, deleteIDs); });
+            ForEachClient(c => c.SendKillObject(deleteIDs));
        }
        #endregion
@@ -3763,13 +3771,13 @@ namespace OpenSim.Region.Framework.Scenes
        /// is activated later when the viewer sends the initial UseCircuitCodePacket UDP packet (in the case of
        /// the LLUDP stack).
        /// </remarks>
-        /// <param name="agent">CircuitData of the agent who is connecting</param>
+        /// <param name="acd">CircuitData of the agent who is connecting</param>
        /// <param name="reason">Outputs the reason for the false response on this string</param>
        /// <param name="requirePresenceLookup">True for normal presence. False for NPC
        /// or other applications where a full grid/Hypergrid presence may not be required.</param>
        /// <returns>True if the region accepts this agent.  False if it does not.  False will 
        /// also return a reason.</returns>
-        public bool NewUserConnection(AgentCircuitData agent, uint teleportFlags, out string reason, bool requirePresenceLookup)
+        public bool NewUserConnection(AgentCircuitData acd, uint teleportFlags, out string reason, bool requirePresenceLookup)
        {
            bool vialogin = ((teleportFlags & (uint)TPFlags.ViaLogin) != 0 ||
                (teleportFlags & (uint)TPFlags.ViaHGLogin) != 0);
@@ -3789,15 +3797,15 @@ namespace OpenSim.Region.Framework.Scenes
            m_log.DebugFormat(
                "[SCENE]: Region {0} told of incoming {1} agent {2} {3} {4} (circuit code {5}, IP {6}, viewer {7}, teleportflags ({8}), position {9})",
                RegionInfo.RegionName,
-                (agent.child ? "child" : "root"),
+                (acd.child ? "child" : "root"),
-                agent.firstname,
+                acd.firstname,
-                agent.lastname,
+                acd.lastname,
-                agent.AgentID,
+                acd.AgentID,
-                agent.circuitcode,
+                acd.circuitcode,
-                agent.IPAddress,
+                acd.IPAddress,
-                agent.Viewer,
+                acd.Viewer,
                ((TPFlags)teleportFlags).ToString(),
-                agent.startpos
+                acd.startpos
            );
            if (!LoginsEnabled)
@@ -3815,7 +3823,7 @@ namespace OpenSim.Region.Framework.Scenes
            {
                foreach (string viewer in m_AllowedViewers)
                {
-                    if (viewer == agent.Viewer.Substring(0, viewer.Length).Trim().ToLower())
+                    if (viewer == acd.Viewer.Substring(0, viewer.Length).Trim().ToLower())
                    {
                        ViewerDenied = false;
                        break;
@@ -3832,7 +3840,7 @@ namespace OpenSim.Region.Framework.Scenes
            {
                foreach (string viewer in m_BannedViewers)
                {
-                    if (viewer == agent.Viewer.Substring(0, viewer.Length).Trim().ToLower())
+                    if (viewer == acd.Viewer.Substring(0, viewer.Length).Trim().ToLower())
                    {
                        ViewerDenied = true;
                        break;
@@ -3844,54 +3852,129 @@ namespace OpenSim.Region.Framework.Scenes
            {
                m_log.DebugFormat(
                    "[SCENE]: Access denied for {0} {1} using {2}",
-                    agent.firstname, agent.lastname, agent.Viewer);
+                    acd.firstname, acd.lastname, acd.Viewer);
                reason = "Access denied, your viewer is banned by the region owner";
                return false;
-            }           
+            }
-            ScenePresence sp = GetScenePresence(agent.AgentID);
+            ILandObject land;
+            ScenePresence sp;
-            // If we have noo presence here or if that presence is a zombie root
+            lock (m_removeClientLock)
-            // presence that will be kicled, we need a new CAPS object.
-            if (sp == null || (sp != null && !sp.IsChildAgent))
            {
-                if (CapsModule != null)
+                sp = GetScenePresence(acd.AgentID);
+                // We need to ensure that we are not already removing the scene presence before we ask it not to be 
+                // closed.
+                if (sp != null && sp.IsChildAgent 
+                    && (sp.LifecycleState == ScenePresenceState.Running 
+                        || sp.LifecycleState == ScenePresenceState.PreRemove))
                {
-                    lock (agent)
+                    m_log.DebugFormat(
+                        "[SCENE]: Reusing existing child scene presence for {0}, state {1} in {2}", 
+                        sp.Name, sp.LifecycleState, Name);
+                    // In the case where, for example, an A B C D region layout, an avatar may
+                    // teleport from A -> D, but then -> C before A has asked B to close its old child agent.  When C
+                    // renews the lease on the child agent at B, we must make sure that the close from A does not succeed.
+                    //
+                    // XXX: In the end, this should not be necessary if child agents are closed without delay on 
+                    // teleport, since realistically, the close request should always be processed before any other
+                    // region tried to re-establish a child agent.  This is much simpler since the logic below is 
+                    // vulnerable to an issue when a viewer quits a region without sending a proper logout but then
+                    // re-establishes the connection on a relogin.  This could wrongly set the DoNotCloseAfterTeleport
+                    // flag when no teleport had taken place (and hence no close was going to come).
+//                    if (!acd.ChildrenCapSeeds.ContainsKey(RegionInfo.RegionHandle))
+//                    {
+//                        m_log.DebugFormat(
+//                            "[SCENE]: Setting DoNotCloseAfterTeleport for child scene presence {0} in {1} because source will attempt close.", 
+//                            sp.Name, Name);
+//
+//                        sp.DoNotCloseAfterTeleport = true;
+//                    }
+//                    else if (EntityTransferModule.IsInTransit(sp.UUID))
+                    sp.LifecycleState = ScenePresenceState.Running;
+                    if (EntityTransferModule.IsInTransit(sp.UUID))
                    {
-                        CapsModule.SetAgentCapsSeeds(agent);
+                        sp.DoNotCloseAfterTeleport = true;
-                        CapsModule.CreateCaps(agent.AgentID, agent.circuitcode);
+                        m_log.DebugFormat(
+                            "[SCENE]: Set DoNotCloseAfterTeleport for child scene presence {0} in {1} because this region will attempt end-of-teleport close from a previous close.", 
+                            sp.Name, Name);
                    }
                }
            }
+            // Need to poll here in case we are currently deleting an sp.  Letting threads run over each other will
+            // allow unpredictable things to happen.
            if (sp != null)
            {
-                if (!sp.IsChildAgent)
+                const int polls = 10;
+                const int pollInterval = 1000;
+                int pollsLeft = polls;
+                while (sp.LifecycleState == ScenePresenceState.Removing && pollsLeft-- > 0)
+                    Thread.Sleep(pollInterval);
+                if (sp.LifecycleState == ScenePresenceState.Removing)
                {
-                    // We have a zombie from a crashed session. 
-                    // Or the same user is trying to be root twice here, won't work.
-                    // Kill it.
                    m_log.WarnFormat(
-                        "[SCENE]: Existing root scene presence detected for {0} {1} in {2} when connecting.  Removing existing presence.",
+                        "[SCENE]: Agent {0} in {1} was still being removed after {2}s.  Aborting NewUserConnection.", 
-                        sp.Name, sp.UUID, RegionInfo.RegionName);
+                        sp.Name, Name, polls * pollInterval / 1000);
-                    sp.ControllingClient.Close(true, true);
+                    return false;
-                    sp = null;
+                }
+                else if (polls != pollsLeft)
+                {
+                    m_log.DebugFormat(
+                        "[SCENE]: NewUserConnection for agent {0} in {1} had to wait {2}s for in-progress removal to complete on an old presence.",
+                        sp.Name, Name, polls * pollInterval / 1000);
                }
            }
-            lock (agent)
+            // TODO: can we remove this lock?
+            lock (acd)
            {
-                //On login test land permisions
+                if (sp != null && !sp.IsChildAgent)
+                {
+                    // We have a root agent. Is it in transit?
+                    if (!EntityTransferModule.IsInTransit(sp.UUID))
+                    {
+                        // We have a zombie from a crashed session. 
+                        // Or the same user is trying to be root twice here, won't work.
+                        // Kill it.
+                        m_log.WarnFormat(
+                            "[SCENE]: Existing root scene presence detected for {0} {1} in {2} when connecting.  Removing existing presence.",
+                            sp.Name, sp.UUID, RegionInfo.RegionName);
+                        if (sp.ControllingClient != null)
+                            CloseAgent(sp.UUID, true);
+                        sp = null;
+                    }
+                    //else
+                    //    m_log.WarnFormat("[SCENE]: Existing root scene presence for {0} {1} in {2}, but agent is in trasit", sp.Name, sp.UUID, RegionInfo.RegionName);
+                }
+                // Optimistic: add or update the circuit data with the new agent circuit data and teleport flags.
+                // We need the circuit data here for some of the subsequent checks. (groups, for example)
+                // If the checks fail, we remove the circuit.
+                acd.teleportFlags = teleportFlags;
+                m_authenticateHandler.AddNewCircuit(acd.circuitcode, acd);
+                land = LandChannel.GetLandObject(acd.startpos.X, acd.startpos.Y);
+    
+                // On login test land permisions
                if (vialogin)
                {
                    IUserAccountCacheModule cache = RequestModuleInterface<IUserAccountCacheModule>();
                    if (cache != null)
-                        cache.Remove(agent.firstname + " " + agent.lastname);
+                        cache.Remove(acd.firstname + " " + acd.lastname);
-                    if (!TestLandRestrictions(agent.AgentID, out reason, ref agent.startpos.X, ref agent.startpos.Y))
+                    if (land != null && !TestLandRestrictions(acd.AgentID, out reason, ref acd.startpos.X, ref acd.startpos.Y))
                    {
-                        m_log.DebugFormat("[CONNECTION BEGIN]: Denying access to {0} due to no land access", agent.AgentID.ToString());
+                        m_authenticateHandler.RemoveCircuit(acd.circuitcode);
                        return false;
                    }
                }
@@ -3902,84 +3985,97 @@ namespace OpenSim.Region.Framework.Scenes
                    {
                        try
                        {
-                            if (!VerifyUserPresence(agent, out reason))
+                            if (!VerifyUserPresence(acd, out reason))
+                            {
+                                m_authenticateHandler.RemoveCircuit(acd.circuitcode);
                                return false;
-                        } catch (Exception e)
+                            }
+                        }
+                        catch (Exception e)
                        {
                            m_log.ErrorFormat(
                                "[SCENE]: Exception verifying presence {0}{1}", e.Message, e.StackTrace);
+                            m_authenticateHandler.RemoveCircuit(acd.circuitcode);
                            return false;
                        }
                    }
                    try
                    {
-                        // Always check estate if this is a login. Always
+                        if (!AuthorizeUser(acd, (vialogin ? false : SeeIntoRegion), out reason))
-                        // check if banned regions are to be blacked out.
-                        if (vialogin || (!m_seeIntoBannedRegion))
                        {
-                            if (!AuthorizeUser(agent, out reason))
+                            m_authenticateHandler.RemoveCircuit(acd.circuitcode);
-                            {
+                            return false;
-                                return false;
-                            }
                        }
                    }
                    catch (Exception e)
                    {
                        m_log.ErrorFormat(
                            "[SCENE]: Exception authorizing user {0}{1}", e.Message, e.StackTrace);
+                        m_authenticateHandler.RemoveCircuit(acd.circuitcode);
                        return false;
                    }
                    m_log.InfoFormat(
                        "[SCENE]: Region {0} authenticated and authorized incoming {1} agent {2} {3} {4} (circuit code {5})",
-                        RegionInfo.RegionName, (agent.child ? "child" : "root"), agent.firstname, agent.lastname,
+                        Name, (acd.child ? "child" : "root"), acd.firstname, acd.lastname,
-                        agent.AgentID, agent.circuitcode);
+                        acd.AgentID, acd.circuitcode);
+    
+                    if (CapsModule != null)
+                    {
+                        CapsModule.SetAgentCapsSeeds(acd);
+                        CapsModule.CreateCaps(acd.AgentID, acd.circuitcode);
+                    }
                }
                else
                {
                    // Let the SP know how we got here. This has a lot of interesting
                    // uses down the line.
                    sp.TeleportFlags = (TPFlags)teleportFlags;
+    
                    if (sp.IsChildAgent)
                    {
                        m_log.DebugFormat(
                            "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
-                            agent.AgentID, RegionInfo.RegionName);
+                            acd.AgentID, RegionInfo.RegionName);
+    
                        sp.AdjustKnownSeeds();
                        if (CapsModule != null)
-                            CapsModule.SetAgentCapsSeeds(agent);
+                        {
+                            CapsModule.SetAgentCapsSeeds(acd);
+                            CapsModule.CreateCaps(acd.AgentID, acd.circuitcode);
+                        }
                    }
                }
-            }
-            // In all cases, add or update the circuit data with the new agent circuit data and teleport flags
+                // Try caching an incoming user name much earlier on to see if this helps with an issue
-            agent.teleportFlags = teleportFlags;
+                // where HG users are occasionally seen by others as "Unknown User" because their UUIDName
-            m_authenticateHandler.AddNewCircuit(agent.circuitcode, agent);
+                // request for the HG avatar appears to trigger before the user name is cached.
+                CacheUserName(null, acd);
+            }
            if (CapsModule != null)
            {
-                CapsModule.ActivateCaps(agent.circuitcode);
+                CapsModule.ActivateCaps(acd.circuitcode);
            }
            if (vialogin)
            {
 //                CleanDroppedAttachments();
-                if (TestBorderCross(agent.startpos, Cardinals.E))
+                if (TestBorderCross(acd.startpos, Cardinals.E))
                {
-                    Border crossedBorder = GetCrossedBorder(agent.startpos, Cardinals.E);
+                    Border crossedBorder = GetCrossedBorder(acd.startpos, Cardinals.E);
-                    agent.startpos.X = crossedBorder.BorderLine.Z - 1;
+                    acd.startpos.X = crossedBorder.BorderLine.Z - 1;
                }
-                if (TestBorderCross(agent.startpos, Cardinals.N))
+                if (TestBorderCross(acd.startpos, Cardinals.N))
                {
-                    Border crossedBorder = GetCrossedBorder(agent.startpos, Cardinals.N);
+                    Border crossedBorder = GetCrossedBorder(acd.startpos, Cardinals.N);
-                    agent.startpos.Y = crossedBorder.BorderLine.Z - 1;
+                    acd.startpos.Y = crossedBorder.BorderLine.Z - 1;
                }
                //Mitigate http://opensimulator.org/mantis/view.php?id=3522
@@ -3989,68 +4085,88 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    lock (EastBorders)
                    {
-                        if (agent.startpos.X > EastBorders[0].BorderLine.Z)
+                        if (acd.startpos.X > EastBorders[0].BorderLine.Z)
                        {
                            m_log.Warn("FIX AGENT POSITION");
-                            agent.startpos.X = EastBorders[0].BorderLine.Z * 0.5f;
+                            acd.startpos.X = EastBorders[0].BorderLine.Z * 0.5f;
-                            if (agent.startpos.Z > 720)
+                            if (acd.startpos.Z > 720)
-                                agent.startpos.Z = 720;
+                                acd.startpos.Z = 720;
                        }
                    }
                    lock (NorthBorders)
                    {
-                        if (agent.startpos.Y > NorthBorders[0].BorderLine.Z)
+                        if (acd.startpos.Y > NorthBorders[0].BorderLine.Z)
                        {
                            m_log.Warn("FIX Agent POSITION");
-                            agent.startpos.Y = NorthBorders[0].BorderLine.Z * 0.5f;
+                            acd.startpos.Y = NorthBorders[0].BorderLine.Z * 0.5f;
-                            if (agent.startpos.Z > 720)
+                            if (acd.startpos.Z > 720)
-                                agent.startpos.Z = 720;
+                                acd.startpos.Z = 720;
                        }
                    }
                } else
                {
-                    if (agent.startpos.X > EastBorders[0].BorderLine.Z)
+                    if (acd.startpos.X > EastBorders[0].BorderLine.Z)
                    {
                        m_log.Warn("FIX AGENT POSITION");
-                        agent.startpos.X = EastBorders[0].BorderLine.Z * 0.5f;
+                        acd.startpos.X = EastBorders[0].BorderLine.Z * 0.5f;
-                        if (agent.startpos.Z > 720)
+                        if (acd.startpos.Z > 720)
-                            agent.startpos.Z = 720;
+                            acd.startpos.Z = 720;
                    }
-                    if (agent.startpos.Y > NorthBorders[0].BorderLine.Z)
+                    if (acd.startpos.Y > NorthBorders[0].BorderLine.Z)
                    {
                        m_log.Warn("FIX Agent POSITION");
-                        agent.startpos.Y = NorthBorders[0].BorderLine.Z * 0.5f;
+                        acd.startpos.Y = NorthBorders[0].BorderLine.Z * 0.5f;
-                        if (agent.startpos.Z > 720)
+                        if (acd.startpos.Z > 720)
-                            agent.startpos.Z = 720;
+                            acd.startpos.Z = 720;
                    }
                }
+//                m_log.DebugFormat(
+//                    "[SCENE]: Found telehub object {0} for new user connection {1} to {2}", 
+//                    RegionInfo.RegionSettings.TelehubObject, acd.Name, Name);
                // Honor Estate teleport routing via Telehubs excluding ViaHome and GodLike TeleportFlags
                if (RegionInfo.RegionSettings.TelehubObject != UUID.Zero &&
                    RegionInfo.EstateSettings.AllowDirectTeleport == false &&
                    !viahome && !godlike)
                {
                    SceneObjectGroup telehub = GetSceneObjectGroup(RegionInfo.RegionSettings.TelehubObject);
-                    // Can have multiple SpawnPoints
-                    List<SpawnPoint> spawnpoints = RegionInfo.RegionSettings.SpawnPoints();
+                    if (telehub != null)
-                    if (spawnpoints.Count > 1)
                    {
-                        // We have multiple SpawnPoints, Route the agent to a random or sequential one
+                        // Can have multiple SpawnPoints
-                        if (SpawnPointRouting == "random")
+                        List<SpawnPoint> spawnpoints = RegionInfo.RegionSettings.SpawnPoints();
-                            agent.startpos = spawnpoints[Util.RandomClass.Next(spawnpoints.Count) - 1].GetLocation(
+                        if (spawnpoints.Count > 1)
-                                telehub.AbsolutePosition,
+                        {
-                                telehub.GroupRotation
+                            // We have multiple SpawnPoints, Route the agent to a random or sequential one
-                            );
+                            if (SpawnPointRouting == "random")
+                                acd.startpos = spawnpoints[Util.RandomClass.Next(spawnpoints.Count) - 1].GetLocation(
+                                    telehub.AbsolutePosition,
+                                    telehub.GroupRotation
+                                );
+                            else
+                                acd.startpos = spawnpoints[SpawnPoint()].GetLocation(
+                                    telehub.AbsolutePosition,
+                                    telehub.GroupRotation
+                                );
+                        }
+                        else if (spawnpoints.Count == 1)
+                        {
+                            // We have a single SpawnPoint and will route the agent to it
+                            acd.startpos = spawnpoints[0].GetLocation(telehub.AbsolutePosition, telehub.GroupRotation);
+                        }
                        else
-                            agent.startpos = spawnpoints[SpawnPoint()].GetLocation(
+                        {
-                                telehub.AbsolutePosition,
+                            m_log.DebugFormat(
-                                telehub.GroupRotation
+                                "[SCENE]: No spawnpoints defined for telehub {0} for {1} in {2}.  Continuing.", 
-                            );
+                                RegionInfo.RegionSettings.TelehubObject, acd.Name, Name);
+                        }
                    }
                    else
                    {
-                        // We have a single SpawnPoint and will route the agent to it
+                        m_log.DebugFormat(
-                        agent.startpos = spawnpoints[0].GetLocation(telehub.AbsolutePosition, telehub.GroupRotation);
+                            "[SCENE]: No telehub {0} found to direct {1} in {2}.  Continuing.", 
+                            RegionInfo.RegionSettings.TelehubObject, acd.Name, Name);
                    }
                    return true;
@@ -4063,7 +4179,7 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    if (land.LandData.LandingType == (byte)1 && land.LandData.UserLocation != Vector3.Zero)
                    {
-                        agent.startpos = land.LandData.UserLocation;
+                        acd.startpos = land.LandData.UserLocation;
                    }
                }
                */// This is now handled properly in ScenePresence.MakeRootAgent
@@ -4158,7 +4274,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="reason">outputs the reason to this string</param>
        /// <returns>True if the region accepts this agent.  False if it does not.  False will 
        /// also return a reason.</returns>
-        protected virtual bool AuthorizeUser(AgentCircuitData agent, out string reason)
+        protected virtual bool AuthorizeUser(AgentCircuitData agent, bool bypassAccessControl, out string reason)
        {
            reason = String.Empty;
@@ -4177,67 +4293,75 @@ namespace OpenSim.Region.Framework.Scenes
                }
            }
-            if (RegionInfo.EstateSettings != null)
+            // We only test the things below when we want to cut off
+            // child agents from being present in the scene for which their root
+            // agent isn't allowed. Otherwise, we allow child agents. The test for
+            // the root is done elsewhere (QueryAccess)
+            if (!bypassAccessControl)
            {
-                if (RegionInfo.EstateSettings.IsBanned(agent.AgentID, 0))
+                if (RegionInfo.EstateSettings != null)
                {
-                    m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user is on the banlist",
+                    int flags = GetUserFlags(agent.AgentID);
-                                     agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
+                    if (RegionInfo.EstateSettings.IsBanned(agent.AgentID, flags))
-                    reason = String.Format("Denied access to region {0}: You have been banned from that region.",
+                    {
-                                           RegionInfo.RegionName);
+                        m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user is on the banlist",
-                    return false;
+                                         agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
+                        reason = String.Format("Denied access to region {0}: You have been banned from that region.",
+                                               RegionInfo.RegionName);
+                        return false;
+                    }
                }
-            }
+                else
-            else
-            {
-                m_log.ErrorFormat("[CONNECTION BEGIN]: Estate Settings is null!");
-            }
-            List<UUID> agentGroups = new List<UUID>();
-            if (m_groupsModule != null)
-            {
-                GroupMembershipData[] GroupMembership = m_groupsModule.GetMembershipData(agent.AgentID);
-                if (GroupMembership != null)
                {
-                    for (int i = 0; i < GroupMembership.Length; i++)
+                    m_log.ErrorFormat("[CONNECTION BEGIN]: Estate Settings is null!");
-                        agentGroups.Add(GroupMembership[i].GroupID);
                }
-                else
+                List<UUID> agentGroups = new List<UUID>();
+                if (m_groupsModule != null)
                {
-                    m_log.ErrorFormat("[CONNECTION BEGIN]: GroupMembership is null!");
+                    GroupMembershipData[] GroupMembership = m_groupsModule.GetMembershipData(agent.AgentID);
+                    if (GroupMembership != null)
+                    {
+                        for (int i = 0; i < GroupMembership.Length; i++)
+                            agentGroups.Add(GroupMembership[i].GroupID);
+                    }
+                    else
+                    {
+                        m_log.ErrorFormat("[CONNECTION BEGIN]: GroupMembership is null!");
+                    }
                }
-            }
-            bool groupAccess = false;
+                bool groupAccess = false;
-            UUID[] estateGroups = RegionInfo.EstateSettings.EstateGroups;
+                UUID[] estateGroups = RegionInfo.EstateSettings.EstateGroups;
-            if (estateGroups != null)
+                if (estateGroups != null)
-            {
-                foreach (UUID group in estateGroups)
                {
-                    if (agentGroups.Contains(group))
+                    foreach (UUID group in estateGroups)
                    {
-                        groupAccess = true;
+                        if (agentGroups.Contains(group))
-                        break;
+                        {
+                            groupAccess = true;
+                            break;
+                        }
                    }
                }
-            }
+                else
-            else
+                {
-            {
+                    m_log.ErrorFormat("[CONNECTION BEGIN]: EstateGroups is null!");
-                m_log.ErrorFormat("[CONNECTION BEGIN]: EstateGroups is null!");
+                }
-            }
-            if (!RegionInfo.EstateSettings.PublicAccess &&
+                if (!RegionInfo.EstateSettings.PublicAccess &&
-                !RegionInfo.EstateSettings.HasAccess(agent.AgentID) &&
+                    !RegionInfo.EstateSettings.HasAccess(agent.AgentID) &&
-                !groupAccess)
+                    !groupAccess)
-            {
+                {
-                m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user does not have access to the estate",
+                    m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user does not have access to the estate",
-                                 agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
+                                     agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
-                reason = String.Format("Denied access to private region {0}: You are not on the access list for that region.",
+                    reason = String.Format("Denied access to private region {0}: You are not on the access list for that region.",
-                                       RegionInfo.RegionName);
+                                           RegionInfo.RegionName);
-                return false;
+                    return false;
+                }
            }
            // TODO: estate/region settings are not properly hooked up
@@ -4362,13 +4486,11 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="cAgentData">Agent that contains all of the relevant things about an agent.
        /// Appearance, animations, position, etc.</param>
        /// <returns>true if we handled it.</returns>
-        public virtual bool IncomingChildAgentDataUpdate(AgentData cAgentData)
+        public virtual bool IncomingUpdateChildAgent(AgentData cAgentData)
        {
            m_log.DebugFormat(
                "[SCENE]: Incoming child agent update for {0} in {1}", cAgentData.AgentID, RegionInfo.RegionName);
-            // XPTO: if this agent is not allowed here as root, always return false
            // We have to wait until the viewer contacts this region after receiving EAC.
            // That calls AddNewClient, which finally creates the ScenePresence
            int flags = GetUserFlags(cAgentData.AgentID);
@@ -4382,7 +4504,7 @@ namespace OpenSim.Region.Framework.Scenes
            ILandObject nearestParcel = GetNearestAllowedParcel(cAgentData.AgentID, Constants.RegionSize / 2, Constants.RegionSize / 2);
            if (nearestParcel == null)
            {
-                m_log.DebugFormat(
+                m_log.InfoFormat(
                    "[SCENE]: Denying root agent entry to {0} in {1}: no allowed parcel",
                    cAgentData.AgentID, RegionInfo.RegionName);
@@ -4390,13 +4512,44 @@ namespace OpenSim.Region.Framework.Scenes
            }
            // We have to wait until the viewer contacts this region
-            // after receiving the EnableSimulator HTTP Event Queue message.  This triggers the viewer to send
+            // after receiving the EnableSimulator HTTP Event Queue message (for the v1 teleport protocol) 
-            // a UseCircuitCode packet which in turn calls AddNewClient which finally creates the ScenePresence.
+            // or TeleportFinish (for the v2 teleport protocol).  This triggers the viewer to send
-            ScenePresence childAgentUpdate = WaitGetScenePresence(cAgentData.AgentID);
+            // a UseCircuitCode packet which in turn calls AddNewAgent which finally creates the ScenePresence.
+            ScenePresence sp = WaitGetScenePresence(cAgentData.AgentID);
-            if (childAgentUpdate != null)
+            if (sp != null)
            {
-                childAgentUpdate.ChildAgentDataUpdate(cAgentData);
+                if (cAgentData.SessionID != sp.ControllingClient.SessionId)
+                {
+                    m_log.WarnFormat(
+                        "[SCENE]: Attempt to update agent {0} with invalid session id {1} (possibly from simulator in older version; tell them to update).", 
+                        sp.UUID, cAgentData.SessionID);
+                    Console.WriteLine(String.Format("[SCENE]: Attempt to update agent {0} ({1}) with invalid session id {2}", 
+                        sp.UUID, sp.ControllingClient.SessionId, cAgentData.SessionID));
+                }
+                sp.UpdateChildAgent(cAgentData);
+                int ntimes = 20;
+                if (cAgentData.SenderWantsToWaitForRoot)
+                {
+                    while (sp.IsChildAgent && ntimes-- > 0)
+                        Thread.Sleep(1000);
+                    if (sp.IsChildAgent)
+                        m_log.WarnFormat(
+                            "[SCENE]: Found presence {0} {1} unexpectedly still child in {2}",
+                            sp.Name, sp.UUID, Name);
+                    else
+                        m_log.InfoFormat(
+                            "[SCENE]: Found presence {0} {1} as root in {2} after {3} waits",
+                                sp.Name, sp.UUID, Name, 20 - ntimes);
+                    if (sp.IsChildAgent)
+                        return false;
+                }
                return true;
            }
@@ -4409,12 +4562,17 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        /// <param name="cAgentData">AgentPosition that contains agent positional data so we can know what to send</param>
        /// <returns>true if we handled it.</returns>
-        public virtual bool IncomingChildAgentDataUpdate(AgentPosition cAgentData)
+        public virtual bool IncomingUpdateChildAgent(AgentPosition cAgentData)
        {
            //m_log.Debug(" XXX Scene IncomingChildAgentDataUpdate POSITION in " + RegionInfo.RegionName);
            ScenePresence childAgentUpdate = GetScenePresence(cAgentData.AgentID);
            if (childAgentUpdate != null)
            {
+//                if (childAgentUpdate.ControllingClient.SessionId != cAgentData.SessionID)
+//                    // Only warn for now
+//                    m_log.WarnFormat("[SCENE]: Attempt at updating position of agent {0} with invalid session id {1}. Neighbor running older version?", 
+//                        childAgentUpdate.UUID, cAgentData.SessionID);
                // I can't imagine *yet* why we would get an update if the agent is a root agent..
                // however to avoid a race condition crossing borders..
                if (childAgentUpdate.IsChildAgent)
@@ -4424,7 +4582,7 @@ namespace OpenSim.Region.Framework.Scenes
                    uint tRegionX = RegionInfo.RegionLocX;
                    uint tRegionY = RegionInfo.RegionLocY;
                    //Send Data to ScenePresence
-                    childAgentUpdate.ChildAgentDataUpdate(cAgentData, tRegionX, tRegionY, rRegionX, rRegionY);
+                    childAgentUpdate.UpdateChildAgent(cAgentData, tRegionX, tRegionY, rRegionX, rRegionY);
                    // Not Implemented:
                    //TODO: Do we need to pass the message on to one of our neighbors?
                }
@@ -4451,35 +4609,99 @@ namespace OpenSim.Region.Framework.Scenes
                m_log.WarnFormat(
                    "[SCENE PRESENCE]: Did not find presence with id {0} in {1} before timeout",
                    agentID, RegionInfo.RegionName);
-//            else
-//                m_log.DebugFormat(
-//                    "[SCENE PRESENCE]: Found presence {0} {1} {2} in {3} after {4} waits",
-//                    sp.Name, sp.UUID, sp.IsChildAgent ? "child" : "root", RegionInfo.RegionName, 10 - ntimes);
            return sp;
        }
-        public virtual bool IncomingRetrieveRootAgent(UUID id, out IAgentData agent)
+        /// <summary>
+        /// Authenticated close (via network)
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="force"></param>
+        /// <param name="auth_token"></param>
+        /// <returns></returns>
+        public bool CloseAgent(UUID agentID, bool force, string auth_token)
        {
-            agent = null;
+            //m_log.DebugFormat("[SCENE]: Processing incoming close agent {0} in region {1} with auth_token {2}", agentID, RegionInfo.RegionName, auth_token);
-            ScenePresence sp = GetScenePresence(id);
-            if ((sp != null) && (!sp.IsChildAgent))
+            // Check that the auth_token is valid
+            AgentCircuitData acd = AuthenticateHandler.GetAgentCircuitData(agentID);
+            if (acd == null)
            {
-                sp.IsChildAgent = true;
+                m_log.DebugFormat(
-                return sp.CopyAgent(out agent);
+                    "[SCENE]: Request to close agent {0} but no such agent in scene {1}.  May have been closed previously.", 
+                    agentID, Name);
+                return false;
+            }
+            if (acd.SessionID.ToString() == auth_token)
+            {
+                return CloseAgent(agentID, force);
+            }
+            else
+            {
+                m_log.WarnFormat(
+                    "[SCENE]: Request to close agent {0} with invalid authorization token {1} in {2}", 
+                    agentID, auth_token, Name);
            }
            return false;
        }
-        public bool IncomingCloseAgent(UUID agentID)
+//        public bool IncomingCloseAgent(UUID agentID)
-        {
+//        {
-            return IncomingCloseAgent(agentID, false);
+//            return IncomingCloseAgent(agentID, false);
-        }
+//        }
-        public bool IncomingCloseChildAgent(UUID agentID)
+//        public bool IncomingCloseChildAgent(UUID agentID)
+//        {
+//            return IncomingCloseAgent(agentID, true);
+//        }
+        /// <summary>
+        /// Tell a single client to prepare to close.
+        /// </summary>
+        /// <remarks>
+        /// This should only be called if we may close the client but there will be some delay in so doing.  Meant for
+        /// internal use - other callers should almost certainly called CloseClient().
+        /// </remarks>
+        /// <param name="sp"></param>
+        /// <returns>true if pre-close state notification was successful.  false if the agent
+        /// was not in a state where it could transition to pre-close.</returns>
+        public bool IncomingPreCloseClient(ScenePresence sp)
        {
-            return IncomingCloseAgent(agentID, true);
+            lock (m_removeClientLock)
+            {
+                // We need to avoid a race condition where in, for example, an A B C D region layout, an avatar may
+                // teleport from A -> D, but then -> C before A has asked B to close its old child agent.  We do not
+                // want to obey this close since C may have renewed the child agent lease on B.
+                if (sp.DoNotCloseAfterTeleport)
+                {
+                    m_log.DebugFormat(
+                        "[SCENE]: Not pre-closing {0} agent {1} in {2} since another simulator has re-established the child connection",
+                        sp.IsChildAgent ? "child" : "root", sp.Name, Name);
+                    // Need to reset the flag so that a subsequent close after another teleport can succeed.
+                    sp.DoNotCloseAfterTeleport = false;
+                    return false;
+                }
+                if (sp.LifecycleState != ScenePresenceState.Running)
+                {
+                    m_log.DebugFormat(
+                        "[SCENE]: Called IncomingPreCloseAgent() for {0} in {1} but presence is already in state {2}",
+                        sp.Name, Name, sp.LifecycleState);
+                    return false;
+                }
+                sp.LifecycleState = ScenePresenceState.PreRemove;
+                return true;
+            }
        }
        /// <summary>
@@ -4490,18 +4712,57 @@ namespace OpenSim.Region.Framework.Scenes
        /// Force the agent to close even if it might be in the middle of some other operation.  You do not want to
        /// force unless you are absolutely sure that the agent is dead and a normal close is not working.
        /// </param>
-        public bool IncomingCloseAgent(UUID agentID, bool force)
+        public override bool CloseAgent(UUID agentID, bool force)
        {
-            //m_log.DebugFormat("[SCENE]: Processing incoming close agent for {0}", agentID);
+            ScenePresence sp;
-            ScenePresence presence = m_sceneGraph.GetScenePresence(agentID);
+            lock (m_removeClientLock)
-            if (presence != null)
+            {
+                sp = GetScenePresence(agentID);
+    
+                if (sp == null)
+                {
+                    m_log.DebugFormat(
+                        "[SCENE]: Called CloseClient() with agent ID {0} but no such presence is in {1}", 
+                        agentID, Name);
+    
+                    return false;
+                }
+                if (sp.LifecycleState != ScenePresenceState.Running && sp.LifecycleState != ScenePresenceState.PreRemove)
+                {
+                    m_log.DebugFormat(
+                        "[SCENE]: Called CloseClient() for {0} in {1} but presence is already in state {2}",
+                        sp.Name, Name, sp.LifecycleState);
+                    return false;
+                }
+                // We need to avoid a race condition where in, for example, an A B C D region layout, an avatar may
+                // teleport from A -> D, but then -> C before A has asked B to close its old child agent.  We do not
+                // want to obey this close since C may have renewed the child agent lease on B.
+                if (sp.DoNotCloseAfterTeleport)
+                {
+                    m_log.DebugFormat(
+                        "[SCENE]: Not closing {0} agent {1} in {2} since another simulator has re-established the child connection",
+                        sp.IsChildAgent ? "child" : "root", sp.Name, Name);
+                    // Need to reset the flag so that a subsequent close after another teleport can succeed.
+                    sp.DoNotCloseAfterTeleport = false;
+                    return false;
+                }
+                sp.LifecycleState = ScenePresenceState.Removing;
+            }
+            if (sp != null)
            {
-                presence.ControllingClient.Close(force, force);
+                sp.ControllingClient.Close(force, force);
                return true;
            }
-            // Agent not here
+            // Agent not here 
            return false;
        }
@@ -5091,21 +5352,6 @@ namespace OpenSim.Region.Framework.Scenes
        #endregion
-        public void RegionHandleRequest(IClientAPI client, UUID regionID)
-        {
-            ulong handle = 0;
-            if (regionID == RegionInfo.RegionID)
-                handle = RegionInfo.RegionHandle;
-            else
-            {
-                GridRegion r = GridService.GetRegionByUUID(UUID.Zero, regionID);
-                if (r != null)
-                    handle = r.RegionHandle;
-            }
-            if (handle != 0)
-                client.SendRegionHandle(regionID, handle);
-        }
 // Commented pending deletion since this method no longer appears to do anything at all
 //        public bool NeedSceneCacheClear(UUID agentID)
@@ -5657,12 +5903,12 @@ Environment.Exit(1);
           List<SceneObjectGroup> objects, 
           out float minX, out float maxX, out float minY, out float maxY, out float minZ, out float maxZ)
        {
-            minX = 256;
+            minX = float.MaxValue;
-            maxX = -256;
+            maxX = float.MinValue;
-            minY = 256;
+            minY = float.MaxValue;
-            maxY = -256;
+            maxY = float.MinValue;
-            minZ = 8192;
+            minZ = float.MaxValue;
-            maxZ = -256;
+            maxZ = float.MinValue;
            List<Vector3> offsets = new List<Vector3>();
@@ -5802,17 +6048,6 @@ Environment.Exit(1);
        {
            reason = "You are banned from the region";
-            if (EntityTransferModule.IsInTransit(agentID))
-            {
-                reason = "Agent is still in transit from this region";
-                m_log.WarnFormat(
-                    "[SCENE]: Denying agent {0} entry into {1} since region still has them registered as in transit",
-                    agentID, RegionInfo.RegionName);
-                return false;
-            }
            if (Permissions.IsGod(agentID))
            {
                reason = String.Empty;
@@ -5862,9 +6097,9 @@ Environment.Exit(1);
            try
            {
-                if (!AuthorizeUser(aCircuit, out reason))
+                if (!AuthorizeUser(aCircuit, false, out reason))
                {
-                    // m_log.DebugFormat("[SCENE]: Denying access for {0}", agentID);
+                    //m_log.DebugFormat("[SCENE]: Denying access for {0}", agentID);
                    return false;
                }
            }
diff --git a/OpenSim/Region/Framework/Scenes/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
index 74c9582..08e26c5 100644
--- a/OpenSim/Region/Framework/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -42,7 +42,8 @@ namespace OpenSim.Region.Framework.Scenes
 {
    public abstract class SceneBase : IScene
    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        protected static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        protected static readonly string LogHeader = "[SCENE]";
        #region Events
@@ -217,8 +218,9 @@ namespace OpenSim.Region.Framework.Scenes
        #region Add/Remove Agent/Avatar
-        public abstract ISceneAgent AddNewClient(IClientAPI client, PresenceType type);
+        public abstract ISceneAgent AddNewAgent(IClientAPI client, PresenceType type);
-        public abstract void RemoveClient(UUID agentID, bool closeChildAgents);
+        public abstract bool CloseAgent(UUID agentID, bool force);
        public bool TryGetScenePresence(UUID agentID, out object scenePresence)
        {
@@ -562,6 +564,10 @@ namespace OpenSim.Region.Framework.Scenes
            get { return false; }
        }
+        public virtual void Start()
+        {
+        }
        public void Restart()
        {
            // This has to be here to fire the event
diff --git a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
index 775a4c2..52f46f2 100644
--- a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
@@ -200,7 +200,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// This Closes child agents on neighboring regions
        /// Calls an asynchronous method to do so..  so it doesn't lag the sim.
        /// </summary>
-        protected void SendCloseChildAgentAsync(UUID agentID, ulong regionHandle)
+        protected void SendCloseChildAgent(UUID agentID, ulong regionHandle, string auth_token)
        {
            // let's do our best, but there's not much we can do if the neighbour doesn't accept.
@@ -209,23 +209,25 @@ namespace OpenSim.Region.Framework.Scenes
            Utils.LongToUInts(regionHandle, out x, out y);
            GridRegion destination = m_scene.GridService.GetRegionByPosition(m_regionInfo.ScopeID, (int)x, (int)y);
-            m_scene.SimulationService.CloseChildAgent(destination, agentID);
-        }
-        private void SendCloseChildAgentCompleted(IAsyncResult iar)
+            m_log.DebugFormat(
-        {
+                "[SCENE COMMUNICATION SERVICE]: Sending close agent ID {0} to {1}", agentID, destination.RegionName);
-            SendCloseChildAgentDelegate icon = (SendCloseChildAgentDelegate)iar.AsyncState;
-            icon.EndInvoke(iar);
+            m_scene.SimulationService.CloseAgent(destination, agentID, auth_token);
        }
-        public void SendCloseChildAgentConnections(UUID agentID, List<ulong> regionslst)
+        /// <summary>
+        /// Closes a child agents in a collection of regions. Does so asynchronously 
+        /// so that the caller doesn't wait.
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="regionslst"></param>
+        public void SendCloseChildAgentConnections(UUID agentID, string auth_code, List<ulong> regionslst)
        {
            foreach (ulong handle in regionslst)
            {
-                SendCloseChildAgentDelegate d = SendCloseChildAgentAsync;
+                ulong handleCopy = handle;
-                d.BeginInvoke(agentID, handle,
+                Util.FireAndForget((o) => { SendCloseChildAgent(agentID, handleCopy, auth_code); });
-                              SendCloseChildAgentCompleted,
-                              d);
            }
        }
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index e599e90..b0f8991 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -631,40 +631,16 @@ namespace OpenSim.Region.Framework.Scenes
        protected internal ScenePresence CreateAndAddChildScenePresence(
            IClientAPI client, AvatarAppearance appearance, PresenceType type)
        {
-            ScenePresence newAvatar = null;
            // ScenePresence always defaults to child agent
-            newAvatar = new ScenePresence(client, m_parentScene, appearance, type);
+            ScenePresence presence = new ScenePresence(client, m_parentScene, appearance, type);
-            AddScenePresence(newAvatar);
-            return newAvatar;
-        }
-        /// <summary>
-        /// Add a presence to the scene
-        /// </summary>
-        /// <param name="presence"></param>
-        protected internal void AddScenePresence(ScenePresence presence)
-        {
-            // Always a child when added to the scene
-            bool child = presence.IsChildAgent;
-            if (child)
-            {
-                m_numChildAgents++;
-            }
-            else
-            {
-                m_numRootAgents++;
-                presence.AddToPhysicalScene(false);
-            }
            Entities[presence.UUID] = presence;
            m_scenePresencesLock.EnterWriteLock();
            try
            {
+                m_numChildAgents++;
                Dictionary<UUID, ScenePresence> newmap = new Dictionary<UUID, ScenePresence>(m_scenePresenceMap);
                List<ScenePresence> newlist = new List<ScenePresence>(m_scenePresenceArray);
@@ -675,7 +651,7 @@ namespace OpenSim.Region.Framework.Scenes
                }
                else
                {
-                    // Remember the old presene reference from the dictionary
+                    // Remember the old presence reference from the dictionary
                    ScenePresence oldref = newmap[presence.UUID];
                    // Replace the presence reference in the dictionary with the new value
                    newmap[presence.UUID] = presence;
@@ -691,6 +667,8 @@ namespace OpenSim.Region.Framework.Scenes
            {
                m_scenePresencesLock.ExitWriteLock();
            }
+            return presence;
        }
        /// <summary>
diff --git a/OpenSim/Region/Framework/Scenes/SceneManager.cs b/OpenSim/Region/Framework/Scenes/SceneManager.cs
index c70342f..c5c083a 100644
--- a/OpenSim/Region/Framework/Scenes/SceneManager.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneManager.cs
@@ -420,29 +420,6 @@ namespace OpenSim.Region.Framework.Scenes
            return false;
        }
-        /// <summary>
-        /// Set the debug packet level on each current scene.  This level governs which packets are printed out to the
-        /// console.
-        /// </summary>
-        /// <param name="newDebug"></param>
-        /// <param name="name">Name of avatar to debug</param>
-        public void SetDebugPacketLevelOnCurrentScene(int newDebug, string name)
-        {
-            ForEachSelectedScene(scene =>
-                scene.ForEachScenePresence(sp =>
-                {
-                    if (name == null || sp.Name == name)
-                    {
-                        m_log.DebugFormat(
-                            "Packet debug for {0} ({1}) set to {2}",
-                            sp.Name, sp.IsChildAgent ? "child" : "root", newDebug);
-                        sp.ControllingClient.DebugPacketLevel = newDebug;
-                    }
-                })
-            );
-        }
        public List<ScenePresence> GetCurrentSceneAvatars()
        {
            List<ScenePresence> avatars = new List<ScenePresence>();
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
index f8624e7..8c50a81 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
@@ -67,6 +67,12 @@ namespace OpenSim.Region.Framework.Scenes
        {
            int scriptsStarted = 0;
+            if (m_scene == null)
+            {
+                m_log.DebugFormat("[PRIM INVENTORY]: m_scene is null. Unable to create script instances");
+                return 0;
+            }
            // Don't start scripts if they're turned off in the region!
            if (!m_scene.RegionInfo.RegionSettings.DisableScripts)
            {
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 86f60bb..cfa862e 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -111,6 +111,9 @@ namespace OpenSim.Region.Framework.Scenes
            STATUS_ROTATE_Z = 0x008,
        }
+        // This flag has the same purpose as InventoryItemFlags.ObjectSlamPerm
+        public static readonly uint SLAM = 16;
        // private PrimCountTaintedDelegate handlerPrimCountTainted = null;
        /// <summary>
@@ -506,9 +509,7 @@ namespace OpenSim.Region.Framework.Scenes
        {
            return (IsAttachment || (m_rootPart.Shape.PCode == 9 && m_rootPart.Shape.State != 0));
        }
+        
        private struct avtocrossInfo
        {
            public ScenePresence av;
@@ -660,12 +661,6 @@ namespace OpenSim.Region.Framework.Scenes
                    }
                }
-/* don't see the need but worse don't see where is restored to false if things stay in
-                foreach (SceneObjectPart part in m_parts.GetArray())
-                {
-                    part.IgnoreUndoUpdate = true;
-                }
- */
                if (RootPart.GetStatusSandbox())
                {
                    if (Util.GetDistanceTo(RootPart.StatusSandboxPos, value) > 10)
@@ -751,7 +746,6 @@ namespace OpenSim.Region.Framework.Scenes
            }
            agent.ParentUUID = UUID.Zero;
 //                agent.Reset();
 //            else // Not successful
 //                agent.RestoreInCurrentScene();
@@ -1667,7 +1661,8 @@ namespace OpenSim.Region.Framework.Scenes
            ScenePresence avatar = m_scene.GetScenePresence(AttachedAvatar);
            if (avatar == null)
                return;
+            m_rootPart.Shape.LastAttachPoint = m_rootPart.Shape.State;
+            m_rootPart.AttachedPos = m_rootPart.OffsetPosition;
            avatar.RemoveAttachment(this);
            Vector3 detachedpos = new Vector3(127f,127f,127f);
@@ -1868,11 +1863,11 @@ namespace OpenSim.Region.Framework.Scenes
        /// <summary>
        /// Delete this group from its scene.
        /// </summary>
-        /// 
+        /// <remarks>
        /// This only handles the in-world consequences of deletion (e.g. any avatars sitting on it are forcibly stood
        /// up and all avatars receive notification of its removal.  Removal of the scene object from database backup
        /// must be handled by the caller.
-        /// 
+        /// </remarks>
        /// <param name="silent">If true then deletion is not broadcast to clients</param>
        public void DeleteGroupFromScene(bool silent)
        {
@@ -1901,7 +1896,7 @@ namespace OpenSim.Region.Framework.Scenes
                                if (!IsAttachment
                                    || AttachedAvatar == avatar.ControllingClient.AgentId
                                    || !HasPrivateAttachmentPoint)
-                                    avatar.ControllingClient.SendKillObject(m_regionHandle, new List<uint> { part.LocalId });
+                                    avatar.ControllingClient.SendKillObject(new List<uint> { part.LocalId });
                            }
                        }
                    });
@@ -2109,6 +2104,7 @@ namespace OpenSim.Region.Framework.Scenes
                        if (RootPart.Shape.PCode == 9 && RootPart.Shape.State != 0)
                        {
+                            RootPart.Shape.LastAttachPoint = RootPart.Shape.State;
                            RootPart.Shape.State = 0;
                            ScheduleGroupForFullUpdate();
                        }
@@ -2210,7 +2206,7 @@ namespace OpenSim.Region.Framework.Scenes
            if (!userExposed)
                dupe.IsAttachment = true;
-            dupe.AbsolutePosition = new Vector3(AbsolutePosition.X, AbsolutePosition.Y, AbsolutePosition.Z);
+            dupe.m_sittingAvatars = new List<UUID>();
            if (!userExposed)
            {
@@ -3813,20 +3809,20 @@ namespace OpenSim.Region.Framework.Scenes
        /// <summary>
        /// Update just the root prim position in a linkset
        /// </summary>
-        /// <param name="pos"></param>
+        /// <param name="newPos"></param>
-        public void UpdateRootPosition(Vector3 pos)
+        public void UpdateRootPosition(Vector3 newPos)
        {
            // needs to be called with phys building true
-            Vector3 newPos = new Vector3(pos.X, pos.Y, pos.Z);
+            Vector3 oldPos;
-            Vector3 oldPos =
-                new Vector3(AbsolutePosition.X + m_rootPart.OffsetPosition.X,
+            if (IsAttachment)
-                              AbsolutePosition.Y + m_rootPart.OffsetPosition.Y,
+                oldPos = m_rootPart.AttachedPos + m_rootPart.OffsetPosition;  // OffsetPosition should always be 0 in an attachments's root prim
-                              AbsolutePosition.Z + m_rootPart.OffsetPosition.Z);
+            else
+                oldPos = AbsolutePosition + m_rootPart.OffsetPosition;
            Vector3 diff = oldPos - newPos;
-            Vector3 axDiff = new Vector3(diff.X, diff.Y, diff.Z);
            Quaternion partRotation = m_rootPart.RotationOffset;
-            axDiff *= Quaternion.Inverse(partRotation);
+            diff *= Quaternion.Inverse(partRotation);
-            diff = axDiff;
            SceneObjectPart[] parts = m_parts.GetArray();
            for (int i = 0; i < parts.Length; i++)
@@ -3837,6 +3833,9 @@ namespace OpenSim.Region.Framework.Scenes
            }
            AbsolutePosition = newPos;
+            
+            if (IsAttachment)
+                m_rootPart.AttachedPos = newPos;
            HasGroupChanged = true;
            if (m_rootPart.Undoing)
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 261e958..ce9baaa 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -231,6 +231,13 @@ namespace OpenSim.Region.Framework.Scenes
        public double SoundRadius;
+        /// <summary>
+        /// Should sounds played from this prim be queued?
+        /// </summary>
+        /// <remarks>
+        /// This should only be changed by sound modules.  It is up to sound modules as to how they interpret this setting.
+        /// </remarks>
+        public bool SoundQueueing { get; set; }
        public uint TimeStampFull;
@@ -383,8 +390,6 @@ namespace OpenSim.Region.Framework.Scenes
        private SOPVehicle m_vehicleParams = null;
-        private KeyframeMotion m_keyframeMotion = null;
        public KeyframeMotion KeyframeMotion
        {
            get; set;
@@ -506,7 +511,7 @@ namespace OpenSim.Region.Framework.Scenes
        {
            get
            {
-                if (CreatorData != null && CreatorData != string.Empty)
+                if (!string.IsNullOrEmpty(CreatorData))
                    return CreatorID.ToString() + ';' + CreatorData;
                else
                    return CreatorID.ToString();
@@ -536,7 +541,11 @@ namespace OpenSim.Region.Framework.Scenes
                        CreatorID = uuid;
                    }
                    if (parts.Length >= 2)
+                    {
                        CreatorData = parts[1];
+                        if (!CreatorData.EndsWith("/"))
+                            CreatorData += "/";
+                    }
                    if (parts.Length >= 3)
                        name = parts[2];
@@ -815,7 +824,8 @@ namespace OpenSim.Region.Framework.Scenes
                        }
                        // Tell the physics engines that this prim changed.
-                        ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(actor);
+                        if (ParentGroup != null && ParentGroup.Scene != null && ParentGroup.Scene.PhysicsScene != null)
+                            ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(actor);
                    }
                    catch (Exception e)
                    {
@@ -933,7 +943,7 @@ namespace OpenSim.Region.Framework.Scenes
                            //m_log.Info("[PART]: RO2:" + actor.Orientation.ToString());
                        }
-                        if (ParentGroup != null)
+                        if (ParentGroup != null && ParentGroup.Scene != null && ParentGroup.Scene.PhysicsScene != null)
                            ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(actor);
                        //}
                    }
@@ -1218,23 +1228,14 @@ namespace OpenSim.Region.Framework.Scenes
        // the mappings more consistant.
        public Vector3 SitTargetPositionLL
        {
-            get { return new Vector3(m_sitTargetPosition.X, m_sitTargetPosition.Y,m_sitTargetPosition.Z); }
+            get { return m_sitTargetPosition; }
            set { m_sitTargetPosition = value; }
        }
        public Quaternion SitTargetOrientationLL
        {
-            get
+            get { return m_sitTargetOrientation; }
-            {
+            set { m_sitTargetOrientation = value; }
-                return new Quaternion(
-                                        m_sitTargetOrientation.X,
-                                        m_sitTargetOrientation.Y,
-                                        m_sitTargetOrientation.Z,
-                                        m_sitTargetOrientation.W
-                                        );
-            }
-            set { m_sitTargetOrientation = new Quaternion(value.X, value.Y, value.Z, value.W); }
        }
        public bool Stopped
@@ -2959,6 +2960,26 @@ namespace OpenSim.Region.Framework.Scenes
                //ParentGroup.RootPart.m_groupPosition = newpos;
            }
+            if (pa != null && ParentID != 0 && ParentGroup != null)
+            {
+                // Special case where a child object is requesting property updates.
+                // This happens when linksets are modified to use flexible links rather than
+                //    the default links.
+                // The simulator code presumes that child parts are only modified by scripts
+                //    so the logic for changing position/rotation/etc does not take into
+                //    account the physical object actually moving.
+                // This code updates the offset position and rotation of the child and then
+                //    lets the update code push the update to the viewer.
+                // Since physics engines do not normally generate this event for linkset children,
+                //    this code will not be active unless you have a specially configured
+                //    physics engine.
+                Quaternion invRootRotation = Quaternion.Normalize(Quaternion.Inverse(ParentGroup.RootPart.RotationOffset));
+                m_offsetPosition = pa.Position - m_groupPosition;
+                RotationOffset = pa.Orientation * invRootRotation;
+                // m_log.DebugFormat("{0} PhysicsRequestingTerseUpdate child: pos={1}, rot={2}, offPos={3}, offRot={4}",
+                //                     "[SCENE OBJECT PART]", pa.Position, pa.Orientation, m_offsetPosition, RotationOffset);
+            }
            ScheduleTerseUpdate();
        }
@@ -3137,7 +3158,8 @@ namespace OpenSim.Region.Framework.Scenes
                return;
            // This was pulled from SceneViewer. Attachments always receive full updates.
-            // I could not verify if this is a requirement but this maintains existing behavior
+            // This is needed because otherwise if only the root prim changes position, then
+            // it looks as if the entire object has moved (including the other prims).
            if (ParentGroup.IsAttachment)
            {
                ScheduleFullUpdate();
@@ -4350,30 +4372,31 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
-        public void UpdateGroupPosition(Vector3 pos)
+        public void UpdateGroupPosition(Vector3 newPos)
        {
-            if ((pos.X != GroupPosition.X) ||
+            Vector3 oldPos = GroupPosition;
-                (pos.Y != GroupPosition.Y) ||
-                (pos.Z != GroupPosition.Z))
+            if ((newPos.X != oldPos.X) ||
+                (newPos.Y != oldPos.Y) ||
+                (newPos.Z != oldPos.Z))
            {
-                Vector3 newPos = new Vector3(pos.X, pos.Y, pos.Z);
                GroupPosition = newPos;
                ScheduleTerseUpdate();
            }
        }
        /// <summary>
-        ///
+        /// Update this part's offset position.
        /// </summary>
        /// <param name="pos"></param>
-        public void UpdateOffSet(Vector3 pos)
+        public void UpdateOffSet(Vector3 newPos)
        {
-            if ((pos.X != OffsetPosition.X) ||
+            Vector3 oldPos = OffsetPosition;
-                (pos.Y != OffsetPosition.Y) ||
-                (pos.Z != OffsetPosition.Z))
-            {
-                Vector3 newPos = new Vector3(pos.X, pos.Y, pos.Z);
+            if ((newPos.X != oldPos.X) ||
+                (newPos.Y != oldPos.Y) ||
+                (newPos.Z != oldPos.Z))
+            {
                if (ParentGroup.RootPart.GetStatusSandbox())
                {
                    if (Util.GetDistanceTo(ParentGroup.RootPart.StatusSandboxPos, newPos) > 10)
@@ -4520,7 +4543,7 @@ namespace OpenSim.Region.Framework.Scenes
            // For now, we use the NINJA naming scheme for identifying joints.
            // In the future, we can support other joint specification schemes such as a 
            // custom checkbox in the viewer GUI.
-            if (ParentGroup.Scene != null && ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
+            if (ParentGroup.Scene != null && ParentGroup.Scene.PhysicsScene != null && ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
            {
                return IsHingeJoint() || IsBallJoint();
            }
@@ -4642,6 +4665,11 @@ namespace OpenSim.Region.Framework.Scenes
                            }
                        }
 */
+                        if (pa != null)
+                        {
+                            pa.SetMaterial(Material);
+                            DoPhysicsPropertyUpdate(UsePhysics, true);
+                        }
                    }
                    else // it already has a physical representation
                    {
@@ -5014,6 +5042,14 @@ namespace OpenSim.Region.Framework.Scenes
                oldTex.DefaultTexture = fallbackOldFace;
            }
+            // Materials capable viewers can send a ObjectImage packet
+            // when nothing in TE has changed. MaterialID should be updated
+            // by the RenderMaterials CAP handler, so updating it here may cause a
+            // race condtion. Therefore, if no non-materials TE fields have changed, 
+            // we should ignore any changes and not update Shape.TextureEntry
+            bool otherFieldsChanged = false;
            for (int i = 0 ; i < GetNumberOfSides(); i++)
            {
@@ -5040,18 +5076,36 @@ namespace OpenSim.Region.Framework.Scenes
                // Max change, skip the rest of testing
                if (changeFlags == (Changed.TEXTURE | Changed.COLOR))
                    break;
+                if (!otherFieldsChanged)
+                {
+                    if (oldFace.Bump != newFace.Bump) otherFieldsChanged = true;
+                    if (oldFace.Fullbright != newFace.Fullbright) otherFieldsChanged = true;
+                    if (oldFace.Glow != newFace.Glow) otherFieldsChanged = true;
+                    if (oldFace.MediaFlags != newFace.MediaFlags) otherFieldsChanged = true;
+                    if (oldFace.OffsetU != newFace.OffsetU) otherFieldsChanged = true;
+                    if (oldFace.OffsetV != newFace.OffsetV) otherFieldsChanged = true;
+                    if (oldFace.RepeatU != newFace.RepeatU) otherFieldsChanged = true;
+                    if (oldFace.RepeatV != newFace.RepeatV) otherFieldsChanged = true;
+                    if (oldFace.Rotation != newFace.Rotation) otherFieldsChanged = true;
+                    if (oldFace.Shiny != newFace.Shiny) otherFieldsChanged = true;
+                    if (oldFace.TexMapType != newFace.TexMapType) otherFieldsChanged = true;
+                }
            }
-            m_shape.TextureEntry = newTex.GetBytes();
+            if (changeFlags != 0 || otherFieldsChanged)
-            if (changeFlags != 0)
+            {
-                TriggerScriptChangedEvent(changeFlags);
+                m_shape.TextureEntry = newTex.GetBytes();
-            UpdateFlag = UpdateRequired.FULL;
+                if (changeFlags != 0)
-            ParentGroup.HasGroupChanged = true;
+                    TriggerScriptChangedEvent(changeFlags);
+                UpdateFlag = UpdateRequired.FULL;
+                ParentGroup.HasGroupChanged = true;
-            //This is madness..
+                //This is madness..
-            //ParentGroup.ScheduleGroupForFullUpdate();
+                //ParentGroup.ScheduleGroupForFullUpdate();
-            //This is sparta
+                //This is sparta
-            ScheduleFullUpdate();
+                ScheduleFullUpdate();
+            }
        }
@@ -5239,6 +5293,64 @@ namespace OpenSim.Region.Framework.Scenes
        {
            ParentGroup.AddScriptLPS(count);
        }
+        /// <summary>
+        /// Sets a prim's owner and permissions when it's rezzed.
+        /// </summary>
+        /// <param name="item">The inventory item from which the item was rezzed</param>
+        /// <param name="userInventory">True: the item is being rezzed from the user's inventory. False: from a prim's inventory.</param>
+        /// <param name="scene">The scene the prim is being rezzed into</param>
+        public void ApplyPermissionsOnRez(InventoryItemBase item, bool userInventory, Scene scene)
+        {
+            if ((OwnerID != item.Owner) || ((item.CurrentPermissions & SceneObjectGroup.SLAM) != 0) || ((item.Flags & (uint)InventoryItemFlags.ObjectSlamPerm) != 0))
+            {
+                if (scene.Permissions.PropagatePermissions())
+                {
+                    if ((item.Flags & (uint)InventoryItemFlags.ObjectHasMultipleItems) == 0)
+                    {
+                        // Apply the item's permissions to the object
+                        //LogPermissions("Before applying item permissions");
+                        if (userInventory)
+                        {
+                            EveryoneMask = item.EveryOnePermissions;
+                            NextOwnerMask = item.NextPermissions;
+                        }
+                        else
+                        {
+                            if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteEveryone) != 0)
+                                EveryoneMask = item.EveryOnePermissions;
+                            if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteNextOwner) != 0)
+                                NextOwnerMask = item.NextPermissions;
+                            if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteGroup) != 0)
+                                GroupMask = item.GroupPermissions;
+                        }
+                        //LogPermissions("After applying item permissions");
+                    }
+                }
+                GroupMask = 0; // DO NOT propagate here
+            }
+            if (OwnerID != item.Owner)
+            {
+                //LogPermissions("Before ApplyNextOwnerPermissions");
+                ApplyNextOwnerPermissions();
+                //LogPermissions("After ApplyNextOwnerPermissions");
+                LastOwnerID = OwnerID;
+                OwnerID = item.Owner;
+                Inventory.ChangeInventoryOwner(item.Owner);
+            }
+        }
+        /// <summary>
+        /// Logs the prim's permissions. Useful when debugging permission problems.
+        /// </summary>
+        /// <param name="message"></param>
+        private void LogPermissions(String message)
+        {
+            PermissionsUtil.LogPermissions(Name, message, BaseMask, OwnerMask, NextOwnerMask);
+        }
        
        public void ApplyNextOwnerPermissions()
        {
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index d04d87b..8893cc0 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -696,7 +696,8 @@ namespace OpenSim.Region.Framework.Scenes
        /// </param>
        public void StopScriptInstance(TaskInventoryItem item)
        {
-            m_part.ParentGroup.Scene.EventManager.TriggerStopScript(m_part.LocalId, item.ItemID);
+            if (m_part.ParentGroup.Scene != null)
+                m_part.ParentGroup.Scene.EventManager.TriggerStopScript(m_part.LocalId, item.ItemID);
            // At the moment, even stopped scripts are counted as active, which is probably wrong.
 //            m_part.ParentGroup.AddActiveScriptCount(-1);
@@ -880,8 +881,8 @@ namespace OpenSim.Region.Framework.Scenes
            return items;
        }
-        
-        public SceneObjectGroup GetRezReadySceneObject(TaskInventoryItem item)
+        public bool GetRezReadySceneObjects(TaskInventoryItem item, out List<SceneObjectGroup> objlist, out List<Vector3> veclist)
        {
            AssetBase rezAsset = m_part.ParentGroup.Scene.AssetService.Get(item.AssetID.ToString());
@@ -890,70 +891,58 @@ namespace OpenSim.Region.Framework.Scenes
                m_log.WarnFormat(
                    "[PRIM INVENTORY]: Could not find asset {0} for inventory item {1} in {2}", 
                    item.AssetID, item.Name, m_part.Name);
-                return null;
+                objlist = null;
+                veclist = null;
+                return false;
            }
-            string xmlData = Utils.BytesToString(rezAsset.Data);
+            Vector3 bbox;
-            SceneObjectGroup group = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
+            float offsetHeight;
-            group.RootPart.AttachPoint = group.RootPart.Shape.State;
+            bool single = m_part.ParentGroup.Scene.GetObjectsToRez(rezAsset.Data, false, out objlist, out veclist, out bbox, out offsetHeight);
-            group.RootPart.AttachOffset = group.AbsolutePosition;
-            group.RootPart.AttachRotation = group.GroupRotation;
-            group.ResetIDs();
+            for (int i = 0; i < objlist.Count; i++)
+            {
-            SceneObjectPart rootPart = group.GetPart(group.UUID);
+                SceneObjectGroup group = objlist[i];
-            // Since renaming the item in the inventory does not affect the name stored
+                group.RootPart.AttachPoint = group.RootPart.Shape.State;
-            // in the serialization, transfer the correct name from the inventory to the
+                group.RootPart.AttachOffset = group.AbsolutePosition;
-            // object itself before we rez.
+                group.RootPart.AttachRotation = group.GroupRotation;
-            rootPart.Name = item.Name;
-            rootPart.Description = item.Description;
-            SceneObjectPart[] partList = group.Parts;
+                group.ResetIDs();
-            group.SetGroup(m_part.GroupID, null);
+                SceneObjectPart rootPart = group.GetPart(group.UUID);
-            // TODO: Remove magic number badness
+                // Since renaming the item in the inventory does not affect the name stored
-            if ((rootPart.OwnerID != item.OwnerID) || (item.CurrentPermissions & 16) != 0 || (item.Flags & (uint)InventoryItemFlags.ObjectSlamPerm) != 0) // Magic number
+                // in the serialization, transfer the correct name from the inventory to the
-            {
+                // object itself before we rez.
-                if (m_part.ParentGroup.Scene.Permissions.PropagatePermissions())
+                // Only do these for the first object if we are rezzing a coalescence.
+                if (i == 0)
                {
-                    foreach (SceneObjectPart part in partList)
+                    rootPart.Name = item.Name;
-                    {
+                    rootPart.Description = item.Description;
-                        if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteEveryone) != 0)
-                            part.EveryoneMask = item.EveryonePermissions;
-                        if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteNextOwner) != 0)
-                            part.NextOwnerMask = item.NextPermissions;
-                        if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteGroup) != 0)
-                            part.GroupMask = item.GroupPermissions;
-                    }
-                    
-                    group.ApplyNextOwnerPermissions();
                }
-            }
-            foreach (SceneObjectPart part in partList)
+                group.SetGroup(m_part.GroupID, null);
-            {
-                // TODO: Remove magic number badness
+                foreach (SceneObjectPart part in group.Parts)
-                if ((part.OwnerID != item.OwnerID) || (item.CurrentPermissions & 16) != 0 || (item.Flags & (uint)InventoryItemFlags.ObjectSlamPerm) != 0) // Magic number
                {
-                    part.LastOwnerID = part.OwnerID;
+                    // Convert between InventoryItem classes. You can never have too many similar but slightly different classes :)
-                    part.OwnerID = item.OwnerID;
+                    InventoryItemBase dest = new InventoryItemBase(item.ItemID, item.OwnerID);
-                    part.Inventory.ChangeInventoryOwner(item.OwnerID);
+                    dest.BasePermissions = item.BasePermissions;
+                    dest.CurrentPermissions = item.CurrentPermissions;
+                    dest.EveryOnePermissions = item.EveryonePermissions;
+                    dest.GroupPermissions = item.GroupPermissions;
+                    dest.NextPermissions = item.NextPermissions;
+                    dest.Flags = item.Flags;
+                    part.ApplyPermissionsOnRez(dest, false, m_part.ParentGroup.Scene);
                }
-                
-                if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteEveryone) != 0)
+                rootPart.TrimPermissions();
-                    part.EveryoneMask = item.EveryonePermissions;
-                if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteNextOwner) != 0)
-                    part.NextOwnerMask = item.NextPermissions;
-                if ((item.Flags & (uint)InventoryItemFlags.ObjectOverwriteGroup) != 0)
-                    part.GroupMask = item.GroupPermissions;
            }
-            
-            rootPart.TrimPermissions(); 
+            return true;
-            
-            return group;
        }
        
        /// <summary>
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 7004d23..f57d4fe 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -29,7 +29,9 @@ using System;
 using System.Xml;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Threading;
 using System.Timers;
+using Timer = System.Timers.Timer;
 using OpenMetaverse;
 using log4net;
 using Nini.Config;
@@ -73,21 +75,50 @@ namespace OpenSim.Region.Framework.Scenes
    public class ScenePresence : EntityBase, IScenePresence
    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 //        ~ScenePresence()
 //        {
 //            m_log.DebugFormat("[SCENE PRESENCE]: Destructor called on {0}", Name);
 //        }
-        private void TriggerScenePresenceUpdated()
+        public void TriggerScenePresenceUpdated()
        {
            if (m_scene != null)
                m_scene.EventManager.TriggerScenePresenceUpdated(this);
        }
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        public PresenceType PresenceType { get; private set; }
+        private ScenePresenceStateMachine m_stateMachine;
+        /// <summary>
+        /// The current state of this presence.  Governs only the existence lifecycle.  See ScenePresenceStateMachine
+        /// for more details.
+        /// </summary>
+        public ScenePresenceState LifecycleState 
+        { 
+            get
+            {
+                return m_stateMachine.GetState();
+            }
+            set
+            {
+                m_stateMachine.SetState(value);
+            }
+        }
+        /// <summary>
+        /// This exists to prevent race conditions between two CompleteMovement threads if the simulator is slow and
+        /// the viewer fires these in quick succession.
+        /// </summary>
+        /// <remarks>
+        /// TODO: The child -> agent transition should be folded into LifecycleState and the CompleteMovement 
+        /// regulation done there.
+        /// </remarks>
+        private object m_completeMovementLock = new object();
 //        private static readonly byte[] DEFAULT_TEXTURE = AvatarAppearance.GetDefaultTexture().GetBytes();
        private static readonly Array DIR_CONTROL_FLAGS = Enum.GetValues(typeof(Dir_ControlFlags));
        private static readonly Vector3 HEAD_ADJUSTMENT = new Vector3(0f, 0f, 0.3f);
@@ -142,6 +173,8 @@ namespace OpenSim.Region.Framework.Scenes
        private Vector3 m_lastVelocity;
        private Vector3 m_lastSize = new Vector3(0.45f,0.6f,1.9f);
+        private bool m_followCamAuto = false;
        private Vector3? m_forceToApply;
        private int m_userFlags;
@@ -200,7 +233,7 @@ namespace OpenSim.Region.Framework.Scenes
        private float m_sitAvatarHeight = 2.0f;
        private Vector3 m_lastChildAgentUpdatePosition;
-        private Vector3 m_lastChildAgentUpdateCamPosition;
+//        private Vector3 m_lastChildAgentUpdateCamPosition;
        private const int LAND_VELOCITYMAG_MAX = 12;
@@ -290,9 +323,37 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        private Vector3 posLastSignificantMove;
-        // For teleports and crossings callbacks
+        #region For teleports and crossings callbacks
-        string m_callbackURI;
-        UUID m_originRegionID;
+        /// <summary>
+        /// In the V1 teleport protocol, the destination simulator sends ReleaseAgent to this address.
+        /// </summary>
+        private string m_callbackURI;
+        /// <summary>
+        /// Records the region from which this presence originated, if not from login.
+        /// </summary>
+        /// <remarks>
+        /// Also acts as a signal in the teleport V2 process to release UpdateAgent after a viewer has triggered
+        /// CompleteMovement and made the previous child agent a root agent.
+        /// </remarks>
+        private UUID m_originRegionID;
+        /// <summary>
+        /// This object is used as a lock before accessing m_originRegionID to make sure that every thread is seeing
+        /// the very latest value and not using some cached version.  Cannot make m_originRegionID itself volatite as
+        /// it is a value type.
+        /// </summary>
+        private object m_originRegionIDAccessLock = new object();
+        /// <summary>
+        /// Used by the entity transfer module to signal when the presence should not be closed because a subsequent
+        /// teleport is reusing the connection.
+        /// </summary>
+        /// <remarks>May be refactored or move somewhere else soon.</remarks>
+        public bool DoNotCloseAfterTeleport { get; set; }
+        #endregion
        /// <value>
        /// Script engines present in the scene
@@ -309,15 +370,12 @@ namespace OpenSim.Region.Framework.Scenes
        /// <summary>
        /// Record user movement inputs.
        /// </summary>
-        public byte MovementFlag { get; private set; }
+        public uint MovementFlag { get; private set; }
-        private bool m_updateflag;
+        /// <summary>
+        /// Is the agent stop control flag currently active?
-        public bool Updated
+        /// </summary>
-        {
+        public bool AgentControlStopActive { get; private set; }
-            set { m_updateflag = value; }
-            get { return m_updateflag; }
-        }
        private bool m_invulnerable = true;
@@ -462,6 +520,7 @@ namespace OpenSim.Region.Framework.Scenes
                }
                else
                {
+//                    m_log.DebugFormat("[SCENE PRESENCE]: Fetching abs pos where PhysicsActor == null and parent part {0} for {1}", Name, Scene.Name);
                    // Obtain the correct position of a seated avatar.
                    // In addition to providing the correct position while
                    // the avatar is seated, this value will also
@@ -485,7 +544,7 @@ namespace OpenSim.Region.Framework.Scenes
            }
            set
            {
-//                m_log.DebugFormat("[SCENE PRESENCE]: Setting position of {0} in {1} to {2}", Name, Scene.Name, value);
+//                m_log.DebugFormat("[SCENE PRESENCE]: Setting position of {0} to {1} in {2}", Name, value, Scene.Name);
 //                Util.PrintCallStack();
                if (PhysicsActor != null)
@@ -502,10 +561,7 @@ namespace OpenSim.Region.Framework.Scenes
                // Don't update while sitting.  The PhysicsActor above is null whilst sitting.
                if (ParentID == 0)
-                {
                    m_pos = value;
-//                    ParentPosition = Vector3.Zero;
-                }
                //m_log.DebugFormat(
                //    "[ENTITY BASE]: In {0} set AbsolutePosition of {1} to {2}",
@@ -768,6 +824,14 @@ namespace OpenSim.Region.Framework.Scenes
            set { m_speedModifier = value; }
        }
+        /// <summary>
+        /// Modifier for agent movement if we get an AGENT_CONTROL_STOP whilst walking or running
+        /// </summary>
+        /// <remarks>
+        /// AGENT_CONTRL_STOP comes about if user holds down space key on viewers.
+        /// </remarks>
+        private float AgentControlStopSlowWhilstMoving = 0.5f;
        private bool m_forceFly;
        public bool ForceFly
@@ -795,7 +859,7 @@ namespace OpenSim.Region.Framework.Scenes
        public ScenePresence(
            IClientAPI client, Scene world, AvatarAppearance appearance, PresenceType type)
-        {
+        {            
            AttachmentsSyncLock = new Object();
            AllowMovement = true;
            IsChildAgent = true;
@@ -841,6 +905,8 @@ namespace OpenSim.Region.Framework.Scenes
            SetDirectionVectors();
            Appearance = appearance;
+            m_stateMachine = new ScenePresenceStateMachine(this);
        }
        private void RegionHeartbeatEnd(Scene scene)
@@ -874,6 +940,7 @@ namespace OpenSim.Region.Framework.Scenes
        {
            ControllingClient.OnCompleteMovementToRegion += CompleteMovement;
            ControllingClient.OnAgentUpdate += HandleAgentUpdate;
+            ControllingClient.OnAgentCameraUpdate += HandleAgentCamerasUpdate;
            ControllingClient.OnAgentRequestSit += HandleAgentRequestSit;
            ControllingClient.OnAgentSit += HandleAgentSit;
            ControllingClient.OnSetAlwaysRun += HandleSetAlwaysRun;
@@ -927,6 +994,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// <summary>
        /// Turns a child agent into a root agent.
        /// </summary>
+        /// <remarks>
        /// Child agents are logged into neighbouring sims largely to observe changes.  Root agents exist when the
        /// avatar is actual in the sim.  They can perform all actions.
        /// This change is made whenever an avatar enters a region, whether by crossing over from a neighbouring sim,
@@ -934,48 +1002,56 @@ namespace OpenSim.Region.Framework.Scenes
        ///
        /// This method is on the critical path for transferring an avatar from one region to another.  Delay here
        /// delays that crossing.
-        /// </summary>
+        /// </remarks>
-        public void MakeRootAgent(Vector3 pos, bool isFlying)
+        private bool MakeRootAgent(Vector3 pos, bool isFlying)
        {
-            m_log.DebugFormat(
+            lock (m_completeMovementLock)
-                "[SCENE]: Upgrading child to root agent for {0} in {1}",
-                Name, m_scene.RegionInfo.RegionName);
-            if (ParentUUID != UUID.Zero)
            {
-                m_log.DebugFormat("[SCENE PRESENCE]: Sitting avatar back on prim {0}", ParentUUID);
+                if (!IsChildAgent)
-                SceneObjectPart part = m_scene.GetSceneObjectPart(ParentUUID);
+                    return false;
-                if (part == null)
+                //m_log.DebugFormat("[SCENE]: known regions in {0}: {1}", Scene.RegionInfo.RegionName, KnownChildRegionHandles.Count);
+    //            m_log.InfoFormat(
+    //                "[SCENE]: Upgrading child to root agent for {0} in {1}",
+    //                Name, m_scene.RegionInfo.RegionName);
+                if (ParentUUID != UUID.Zero)
                {
-                    m_log.ErrorFormat("[SCENE PRESENCE]: Can't find prim {0} to sit on", ParentUUID);
+                    m_log.DebugFormat("[SCENE PRESENCE]: Sitting avatar back on prim {0}", ParentUUID);
+                    SceneObjectPart part = m_scene.GetSceneObjectPart(ParentUUID);
+                    if (part == null)
+                    {
+                        m_log.ErrorFormat("[SCENE PRESENCE]: Can't find prim {0} to sit on", ParentUUID);
+                    }
+                    else
+                    {
+                        part.ParentGroup.AddAvatar(UUID);
+                        if (part.SitTargetPosition != Vector3.Zero)
+                            part.SitTargetAvatar = UUID;
+    //                    ParentPosition = part.GetWorldPosition();
+                        ParentID = part.LocalId;
+                        ParentPart = part;
+                        m_pos = PrevSitOffset;
+    //                    pos = ParentPosition;
+                        pos = part.GetWorldPosition();
+                    }
+                    ParentUUID = UUID.Zero;
+    //                Animator.TrySetMovementAnimation("SIT");
                }
                else
                {
-                    part.ParentGroup.AddAvatar(UUID);
+                    IsLoggingIn = false;
-                    if (part.SitTargetPosition != Vector3.Zero)
-                        part.SitTargetAvatar = UUID;
-//                    ParentPosition = part.GetWorldPosition();
-                    ParentID = part.LocalId;
-                    ParentPart = part;
-                    m_pos = PrevSitOffset;
-//                    pos = ParentPosition;
-                    pos = part.GetWorldPosition();
                }
-                ParentUUID = UUID.Zero;
                IsChildAgent = false;
-//                Animator.TrySetMovementAnimation("SIT");
            }
-            else
-            {
-                IsChildAgent = false;
-                IsLoggingIn = false;
-            }
-            //m_log.DebugFormat("[SCENE]: known regions in {0}: {1}", Scene.RegionInfo.RegionName, KnownChildRegionHandles.Count);
-            IsChildAgent = false;
+            // Must reset this here so that a teleport to a region next to an existing region does not keep the flag
+            // set and prevent the close of the connection on a subsequent re-teleport.
+            // Should not be needed if we are not trying to tell this region to close
+//            DoNotCloseAfterTeleport = false;
            IGroupsModule gm = m_scene.RequestModuleInterface<IGroupsModule>();
            if (gm != null)
@@ -1116,22 +1192,36 @@ namespace OpenSim.Region.Framework.Scenes
                // and CHANGED_REGION) when the attachments have been rezzed in the new region.  This cannot currently
                // be done in AttachmentsModule.CopyAttachments(AgentData ad, IScenePresence sp) itself since we are
                // not transporting the required data.
-                lock (m_attachments)
+                //
+                // We need to restart scripts here so that they receive the correct changed events (CHANGED_TELEPORT
+                // and CHANGED_REGION) when the attachments have been rezzed in the new region.  This cannot currently
+                // be done in AttachmentsModule.CopyAttachments(AgentData ad, IScenePresence sp) itself since we are
+                // not transporting the required data.
+                //
+                // We must take a copy of the attachments list here (rather than locking) to avoid a deadlock where a script in one of 
+                // the attachments may start processing an event (which locks ScriptInstance.m_Script) that then calls a method here
+                // which needs to lock m_attachments.  ResumeScripts() needs to take a ScriptInstance.m_Script lock to try to unset the Suspend status.
+                //
+                // FIXME: In theory, this deadlock should not arise since scripts should not be processing events until ResumeScripts().
+                // But XEngine starts all scripts unsuspended.  Starting them suspended will not currently work because script rezzing
+                // is placed in an asynchronous queue in XEngine and so the ResumeScripts() call will almost certainly execute before the 
+                // script is rezzed.  This means the ResumeScripts() does absolutely nothing when using XEngine.
+                //
+                // One cannot simply iterate over attachments in a fire and forget thread because this would no longer
+                // be locked, allowing race conditions if other code changes the attachments list.
+                List<SceneObjectGroup> attachments = GetAttachments();
+                if (attachments.Count > 0)
                {
-                    if (HasAttachments())
+                    m_log.DebugFormat(
-                    {
+                        "[SCENE PRESENCE]: Restarting scripts in attachments for {0} in {1}", Name, Scene.Name);
-                        m_log.DebugFormat(
-                            "[SCENE PRESENCE]: Restarting scripts in attachments for {0} in {1}", Name, Scene.Name);
-                        // Resume scripts
+                    // Resume scripts
-                        Util.FireAndForget(delegate(object x) {
+                    foreach (SceneObjectGroup sog in attachments)
-                            foreach (SceneObjectGroup sog in m_attachments)
+                    {
-                            {
+                        sog.ScheduleGroupForFullUpdate();
-                                sog.ScheduleGroupForFullUpdate();
+                        sog.RootPart.ParentGroup.CreateScriptInstances(0, false, m_scene.DefaultScriptEngine, GetStateSource());
-                                sog.RootPart.ParentGroup.CreateScriptInstances(0, false, m_scene.DefaultScriptEngine, GetStateSource());
+                        sog.ResumeScripts();
-                                sog.ResumeScripts();
-                            }
-                        });
                    }
                }
            }
@@ -1153,7 +1243,7 @@ namespace OpenSim.Region.Framework.Scenes
            m_scene.EventManager.TriggerOnMakeRootAgent(this);
-            m_scene.EventManager.OnRegionHeartbeatEnd += RegionHeartbeatEnd;
+            return true;
        }
        public int GetStateSource()
@@ -1306,7 +1396,26 @@ namespace OpenSim.Region.Framework.Scenes
        public void StopFlying()
        {
-            ControllingClient.StopFlying(this);
+            Vector3 pos = AbsolutePosition; 
+            if (Appearance.AvatarHeight != 127.0f)
+                pos += new Vector3(0f, 0f, (Appearance.AvatarHeight / 6f));
+            else
+                pos += new Vector3(0f, 0f, (1.56f / 6f));
+            AbsolutePosition = pos;
+            // attach a suitable collision plane regardless of the actual situation to force the LLClient to land.
+            // Collision plane below the avatar's position a 6th of the avatar's height is suitable.
+            // Mind you, that this method doesn't get called if the avatar's velocity magnitude is greater then a
+            // certain amount..   because the LLClient wouldn't land in that situation anyway.
+            // why are we still testing for this really old height value default???
+            if (Appearance.AvatarHeight != 127.0f)
+                CollisionPlane = new Vector4(0, 0, 0, pos.Z - Appearance.AvatarHeight / 6f);
+            else
+                CollisionPlane = new Vector4(0, 0, 0, pos.Z - (1.56f / 6f));
+            ControllingClient.SendAgentTerseUpdate(this);
        }
        /// <summary>
@@ -1480,6 +1589,37 @@ namespace OpenSim.Region.Framework.Scenes
            
        }
+        private bool WaitForUpdateAgent(IClientAPI client)
+        {
+            // Before the source region executes UpdateAgent
+            // (which triggers Scene.IncomingUpdateChildAgent(AgentData cAgentData) here in the destination, 
+            // m_originRegionID is UUID.Zero; after, it's non-Zero.  The CompleteMovement sequence initiated from the
+            // viewer (in turn triggered by the source region sending it a TeleportFinish event) waits until it's non-zero
+            int count = 50;
+            UUID originID;
+            lock (m_originRegionIDAccessLock)
+                originID = m_originRegionID;
+            while (originID.Equals(UUID.Zero) && count-- > 0)
+            {
+                lock (m_originRegionIDAccessLock)
+                    originID = m_originRegionID;
+                m_log.DebugFormat("[SCENE PRESENCE]: Agent {0} waiting for update in {1}", client.Name, Scene.Name);
+                Thread.Sleep(200);
+            }
+            if (originID.Equals(UUID.Zero))
+            {
+                // Movement into region will fail
+                m_log.WarnFormat("[SCENE PRESENCE]: Update agent {0} never arrived in {1}", client.Name, Scene.Name);
+                return false;
+            }
+            return true;
+        }
        /// <summary>
        /// Complete Avatar's movement into the region.
        /// </summary>
@@ -1493,9 +1633,18 @@ namespace OpenSim.Region.Framework.Scenes
        {
 //            DateTime startTime = DateTime.Now;
-            m_log.DebugFormat(
+            m_log.InfoFormat(
                "[SCENE PRESENCE]: Completing movement of {0} into region {1} in position {2}",
-                client.Name, Scene.RegionInfo.RegionName, AbsolutePosition);
+                client.Name, Scene.Name, AbsolutePosition);
+            // Make sure it's not a login agent. We don't want to wait for updates during login
+            if (PresenceType != PresenceType.Npc && (m_teleportFlags & TeleportFlags.ViaLogin) == 0)
+            {
+                // Let's wait until UpdateAgent (called by departing region) is done
+                if (!WaitForUpdateAgent(client))
+                    // The sending region never sent the UpdateAgent data, we have to refuse
+                    return;
+            }
            Vector3 look = Velocity;
@@ -1517,12 +1666,25 @@ namespace OpenSim.Region.Framework.Scenes
            }
            bool flying = ((m_AgentControlFlags & AgentManager.ControlFlags.AGENT_CONTROL_FLY) != 0);
-            MakeRootAgent(AbsolutePosition, flying);
+            if (!MakeRootAgent(AbsolutePosition, flying))
+            {
+                m_log.DebugFormat(
+                    "[SCENE PRESENCE]: Aborting CompleteMovement call for {0} in {1} as they are already root", 
+                    Name, Scene.Name);
+                return;
+            }
+            // Tell the client that we're totally ready
            ControllingClient.MoveAgentIntoRegion(m_scene.RegionInfo, AbsolutePosition, look);
+            // Remember in HandleUseCircuitCode, we delayed this to here
+            if (m_teleportFlags > 0)
+                SendInitialDataToMe();
 //            m_log.DebugFormat("[SCENE PRESENCE] Completed movement");
-            if ((m_callbackURI != null) && !m_callbackURI.Equals(""))
+            if (!string.IsNullOrEmpty(m_callbackURI))
            {
                // We cannot sleep here since this would hold up the inbound packet processing thread, as
                // CompleteMovement() is executed synchronously.  However, it might be better to delay the release
@@ -1535,7 +1697,12 @@ namespace OpenSim.Region.Framework.Scenes
                    "[SCENE PRESENCE]: Releasing {0} {1} with callback to {2}",
                    client.Name, client.AgentId, m_callbackURI);
-                Scene.SimulationService.ReleaseAgent(m_originRegionID, UUID, m_callbackURI);
+                UUID originID;
+                lock (m_originRegionIDAccessLock)
+                    originID = m_originRegionID;
+                Scene.SimulationService.ReleaseAgent(originID, UUID, m_callbackURI);
                m_callbackURI = null;
            }
 //            else
@@ -1550,7 +1717,6 @@ namespace OpenSim.Region.Framework.Scenes
            // Create child agents in neighbouring regions
            if (openChildAgents && !IsChildAgent)
            {
                IEntityTransferModule m_agentTransfer = m_scene.RequestModuleInterface<IEntityTransferModule>();
                if (m_agentTransfer != null)
                    m_agentTransfer.EnableChildAgents(this);
@@ -1573,6 +1739,7 @@ namespace OpenSim.Region.Framework.Scenes
 //            m_log.DebugFormat(
 //                "[SCENE PRESENCE]: Completing movement of {0} into region {1} took {2}ms", 
 //                client.Name, Scene.RegionInfo.RegionName, (DateTime.Now - startTime).Milliseconds);
        }
        /// <summary>
@@ -1653,9 +1820,9 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        public void HandleAgentUpdate(IClientAPI remoteClient, AgentUpdateArgs agentData)
        {
-//            m_log.DebugFormat(
+            //m_log.DebugFormat(
-//                "[SCENE PRESENCE]: In {0} received agent update from {1}, flags {2}",
+            //    "[SCENE PRESENCE]: In {0} received agent update from {1}, flags {2}",
-//                Scene.RegionInfo.RegionName, remoteClient.Name, (AgentManager.ControlFlags)agentData.ControlFlags);
+            //    Scene.RegionInfo.RegionName, remoteClient.Name, (AgentManager.ControlFlags)agentData.ControlFlags);
            if (IsChildAgent)
            {
@@ -1663,10 +1830,6 @@ namespace OpenSim.Region.Framework.Scenes
                return;
            }
-            ++m_movementUpdateCount;
-            if (m_movementUpdateCount < 1)
-                m_movementUpdateCount = 1;
            #region Sanity Checking
            // This is irritating.  Really.
@@ -1697,21 +1860,6 @@ namespace OpenSim.Region.Framework.Scenes
            AgentManager.ControlFlags flags = (AgentManager.ControlFlags)agentData.ControlFlags;
-            // Camera location in world.  We'll need to raytrace
-            // from this location from time to time.
-            CameraPosition = agentData.CameraCenter;
-            if (Vector3.Distance(m_lastCameraPosition, CameraPosition) >= Scene.RootReprioritizationDistance)
-            {
-                ReprioritizeUpdates();
-                m_lastCameraPosition = CameraPosition;
-            }
-            // Use these three vectors to figure out what the agent is looking at
-            // Convert it to a Matrix and/or Quaternion
-            CameraAtAxis = agentData.CameraAtAxis;
-            CameraLeftAxis = agentData.CameraLeftAxis;
-            CameraUpAxis = agentData.CameraUpAxis;
            // The Agent's Draw distance setting
            // When we get to the point of re-computing neighbors everytime this
            // changes, then start using the agent's drawdistance rather than the 
@@ -1783,9 +1931,16 @@ namespace OpenSim.Region.Framework.Scenes
            // Here's where you get them.
            m_AgentControlFlags = flags;
            m_headrotation = agentData.HeadRotation;
+            byte oldState = State;
            State = agentData.State;
+            // We need to send this back to the client in order to stop the edit beams
+            if ((oldState & (uint)AgentState.Editing) != 0 && State == (uint)AgentState.None)
+                ControllingClient.SendAgentTerseUpdate(this);
            PhysicsActor actor = PhysicsActor;
+            // This will be the case if the agent is sitting on the groudn or on an object.
            if (actor == null)
            {
                SendControlsToScripts(flagsForScripts);
@@ -1794,12 +1949,13 @@ namespace OpenSim.Region.Framework.Scenes
            if (AllowMovement && !SitGround)
            {
-                Quaternion bodyRotation = agentData.BodyRotation;
+//                m_log.DebugFormat("[SCENE PRESENCE]: Initial body rotation {0} for {1}", agentData.BodyRotation, Name);
                bool update_rotation = false;
-                if (bodyRotation != Rotation)
+                if (agentData.BodyRotation != Rotation)
                {
-                    Rotation = bodyRotation;
+                    Rotation = agentData.BodyRotation;
                    update_rotation = true;
                }
@@ -1845,10 +2001,7 @@ namespace OpenSim.Region.Framework.Scenes
                    else
                        dirVectors = Dir_Vectors;
-                    // The fact that MovementFlag is a byte needs to be fixed
-                    // it really should be a uint
                    // A DIR_CONTROL_FLAG occurs when the user is trying to move in a particular direction.
-                    uint nudgehack = 250;
                    foreach (Dir_ControlFlags DCF in DIR_CONTROL_FLAGS)
                    {
                        if (((uint)flags & (uint)DCF) != 0)
@@ -1865,29 +2018,19 @@ namespace OpenSim.Region.Framework.Scenes
                                // Why did I get this?
                            }
-                            if ((MovementFlag & (byte)(uint)DCF) == 0)
+                            if (((MovementFlag & (uint)DCF) == 0) & !AgentControlStopActive)
-                            {
+                            {   
-                                if (DCF == Dir_ControlFlags.DIR_CONTROL_FLAG_FORWARD_NUDGE || DCF == Dir_ControlFlags.DIR_CONTROL_FLAG_BACKWARD_NUDGE ||
-                                    DCF == Dir_ControlFlags.DIR_CONTROL_FLAG_LEFT_NUDGE || DCF == Dir_ControlFlags.DIR_CONTROL_FLAG_RIGHT_NUDGE)
-                                {
-                                    MovementFlag |= (byte)nudgehack;
-                                }
                                //m_log.DebugFormat("[SCENE PRESENCE]: Updating MovementFlag for {0} with {1}", Name, DCF);
-                                MovementFlag += (byte)(uint)DCF;
+                                MovementFlag += (uint)DCF;
                                update_movementflag = true;
                            }
                        }
                        else
                        {
-                            if ((MovementFlag & (byte)(uint)DCF) != 0 ||
+                            if ((MovementFlag & (uint)DCF) != 0)
-                                ((DCF == Dir_ControlFlags.DIR_CONTROL_FLAG_FORWARD_NUDGE || DCF == Dir_ControlFlags.DIR_CONTROL_FLAG_BACKWARD_NUDGE ||
-                                DCF == Dir_ControlFlags.DIR_CONTROL_FLAG_LEFT_NUDGE || DCF == Dir_ControlFlags.DIR_CONTROL_FLAG_RIGHT_NUDGE)
-                                && ((MovementFlag & (byte)nudgehack) == nudgehack))
-                                ) // This or is for Nudge forward
                            {
                                //m_log.DebugFormat("[SCENE PRESENCE]: Updating MovementFlag for {0} with lack of {1}", Name, DCF);
-                                MovementFlag -= ((byte)(uint)DCF);
+                                MovementFlag -= (uint)DCF;
                                update_movementflag = true;
                                /*
@@ -1907,6 +2050,13 @@ namespace OpenSim.Region.Framework.Scenes
                        i++;
                    }
+                    // Detect AGENT_CONTROL_STOP state changes
+                    if (AgentControlStopActive != ((flags & AgentManager.ControlFlags.AGENT_CONTROL_STOP) != 0))
+                    {
+                        AgentControlStopActive = !AgentControlStopActive;
+                        update_movementflag = true;
+                    }
                    if (MovingToTarget)
                    {
                        // If the user has pressed a key then we want to cancel any move to target.
@@ -1932,53 +2082,79 @@ namespace OpenSim.Region.Framework.Scenes
                // Only do this if we're flying
                if (Flying && !ForceFly)
                {
-                    // Landing detection code
+                    // Need to stop in mid air if user holds down AGENT_CONTROL_STOP
+                    if (AgentControlStopActive)
-                    // Are the landing controls requirements filled?
-                    bool controlland = (((flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0) ||
-                                        ((flags & AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_UP_NEG) != 0));
-                   //m_log.Debug("[CONTROL]: " +flags);
-                    // Applies a satisfying roll effect to the avatar when flying.
-                    if ((flags & AgentManager.ControlFlags.AGENT_CONTROL_TURN_LEFT) != 0 && (flags & AgentManager.ControlFlags.AGENT_CONTROL_YAW_POS) != 0)
-                    {
-                        ApplyFlyingRoll(
-                            FLY_ROLL_RADIANS_PER_UPDATE, 
-                            (flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_POS) != 0, 
-                            (flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0);
-                    } 
-                    else if ((flags & AgentManager.ControlFlags.AGENT_CONTROL_TURN_RIGHT) != 0 &&
-                             (flags & AgentManager.ControlFlags.AGENT_CONTROL_YAW_NEG) != 0)
                    {
-                        ApplyFlyingRoll(
+                        agent_control_v3 = Vector3.Zero;
-                            -FLY_ROLL_RADIANS_PER_UPDATE, 
-                            (flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_POS) != 0, 
-                            (flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0);                      
                    }
                    else
                    {
-                        if (m_AngularVelocity.Z != 0)
+                        // Landing detection code
-                            m_AngularVelocity.Z += CalculateFlyingRollResetToZero(FLY_ROLL_RESET_RADIANS_PER_UPDATE);                        
-                    }                  
-                    if (Flying && IsColliding && controlland)
+                        // Are the landing controls requirements filled?
-                    {
+                        bool controlland = (((flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0) ||
-                        // nesting this check because LengthSquared() is expensive and we don't 
+                                            ((flags & AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_UP_NEG) != 0));
-                        // want to do it every step when flying.
-                        if ((Velocity.LengthSquared() <= LAND_VELOCITYMAG_MAX))
+                       //m_log.Debug("[CONTROL]: " +flags);
-                            StopFlying();
+                        // Applies a satisfying roll effect to the avatar when flying.
+                        if ((flags & AgentManager.ControlFlags.AGENT_CONTROL_TURN_LEFT) != 0 && (flags & AgentManager.ControlFlags.AGENT_CONTROL_YAW_POS) != 0)
+                        {
+                            ApplyFlyingRoll(
+                                FLY_ROLL_RADIANS_PER_UPDATE, 
+                                (flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_POS) != 0, 
+                                (flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0);
+                        } 
+                        else if ((flags & AgentManager.ControlFlags.AGENT_CONTROL_TURN_RIGHT) != 0 &&
+                                 (flags & AgentManager.ControlFlags.AGENT_CONTROL_YAW_NEG) != 0)
+                        {
+                            ApplyFlyingRoll(
+                                -FLY_ROLL_RADIANS_PER_UPDATE, 
+                                (flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_POS) != 0, 
+                                (flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0);                      
+                        }
+                        else
+                        {
+                            if (m_AngularVelocity.Z != 0)
+                                m_AngularVelocity.Z += CalculateFlyingRollResetToZero(FLY_ROLL_RESET_RADIANS_PER_UPDATE);                        
+                        }                  
+                        if (Flying && IsColliding && controlland)
+                        {
+                            // nesting this check because LengthSquared() is expensive and we don't 
+                            // want to do it every step when flying.
+                            if ((Velocity.LengthSquared() <= LAND_VELOCITYMAG_MAX))
+                                StopFlying();
+                        }
                    }
                }
+//                m_log.DebugFormat("[SCENE PRESENCE]: MovementFlag {0} for {1}", MovementFlag, Name);
                // If the agent update does move the avatar, then calculate the force ready for the velocity update,
                // which occurs later in the main scene loop
-                if (update_movementflag || (update_rotation && DCFlagKeyPressed))
+                // We also need to update if the user rotates their avatar whilst it is slow walking/running (if they
+                // held down AGENT_CONTROL_STOP whilst normal walking/running).  However, we do not want to update
+                // if the user rotated whilst holding down AGENT_CONTROL_STOP when already still (which locks the 
+                // avatar location in place).
+                if (update_movementflag 
+                    || (update_rotation && DCFlagKeyPressed && (!AgentControlStopActive || MovementFlag != 0)))
                {
-//                    m_log.DebugFormat(
+//                    if (update_movementflag || !AgentControlStopActive || MovementFlag != 0)
-//                        "[SCENE PRESENCE]: In {0} adding velocity of {1} to {2}, umf = {3}, ur = {4}",
+//                    {
-//                        m_scene.RegionInfo.RegionName, agent_control_v3, Name, update_movementflag, update_rotation);
+//                        m_log.DebugFormat(
+//                            "[SCENE PRESENCE]: In {0} adding velocity of {1} to {2}, umf = {3}, mf = {4}, ur = {5}",
+//                            m_scene.RegionInfo.RegionName, agent_control_v3, Name, 
+//                            update_movementflag, MovementFlag, update_rotation);
-                    AddNewMovement(agent_control_v3);
+                        float speedModifier;
+                        if (AgentControlStopActive)
+                            speedModifier = AgentControlStopSlowWhilstMoving;
+                        else
+                            speedModifier = 1;
+                        AddNewMovement(agent_control_v3, speedModifier);
+//                    }
                }
 //                else
 //                {
@@ -1991,15 +2167,86 @@ namespace OpenSim.Region.Framework.Scenes
 //                }
                if (update_movementflag && ParentID == 0)
+                {
+//                    m_log.DebugFormat("[SCENE PRESENCE]: Updating movement animations for {0}", Name);
                    Animator.UpdateMovementAnimations();
+                }
                SendControlsToScripts(flagsForScripts);
            }
+            // We need to send this back to the client in order to see the edit beams
+            if ((State & (uint)AgentState.Editing) != 0)
+                ControllingClient.SendAgentTerseUpdate(this);
            m_scene.EventManager.TriggerOnClientMovement(this);
-            TriggerScenePresenceUpdated();
        }
+        /// <summary>
+        /// This is the event handler for client cameras. If a client is moving, or moving the camera, this event is triggering.
+        /// </summary>
+        private void HandleAgentCamerasUpdate(IClientAPI remoteClient, AgentUpdateArgs agentData)
+        {
+            //m_log.DebugFormat(
+            //    "[SCENE PRESENCE]: In {0} received agent camera update from {1}, flags {2}",
+            //    Scene.RegionInfo.RegionName, remoteClient.Name, (AgentManager.ControlFlags)agentData.ControlFlags);
+            if (IsChildAgent)
+            {
+                //    // m_log.Debug("DEBUG: HandleAgentUpdate: child agent");
+                return;
+            }
+            ++m_movementUpdateCount;
+            if (m_movementUpdateCount < 1)
+                m_movementUpdateCount = 1;
+//            AgentManager.ControlFlags flags = (AgentManager.ControlFlags)agentData.ControlFlags;
+            // Camera location in world.  We'll need to raytrace
+            // from this location from time to time.
+            CameraPosition = agentData.CameraCenter;
+            if (Vector3.Distance(m_lastCameraPosition, CameraPosition) >= Scene.RootReprioritizationDistance)
+            {
+                ReprioritizeUpdates();
+                m_lastCameraPosition = CameraPosition;
+            }
+            // Use these three vectors to figure out what the agent is looking at
+            // Convert it to a Matrix and/or Quaternion
+            CameraAtAxis = agentData.CameraAtAxis;
+            CameraLeftAxis = agentData.CameraLeftAxis;
+            CameraUpAxis = agentData.CameraUpAxis;
+            // The Agent's Draw distance setting
+            // When we get to the point of re-computing neighbors everytime this
+            // changes, then start using the agent's drawdistance rather than the 
+            // region's draw distance.
+            // DrawDistance = agentData.Far;
+            DrawDistance = Scene.DefaultDrawDistance;
+            // Check if Client has camera in 'follow cam' or 'build' mode.
+            Vector3 camdif = (Vector3.One * Rotation - Vector3.One * CameraRotation);
+            m_followCamAuto = ((CameraUpAxis.Z > 0.959f && CameraUpAxis.Z < 0.98f)
+               && (Math.Abs(camdif.X) < 0.4f && Math.Abs(camdif.Y) < 0.4f)) ? true : false;
+            //m_log.DebugFormat("[FollowCam]: {0}", m_followCamAuto);
+            // Raycast from the avatar's head to the camera to see if there's anything blocking the view
+            if ((m_movementUpdateCount % NumMovementsBetweenRayCast) == 0 && m_scene.PhysicsScene.SupportsRayCast())
+            {
+                if (m_followCamAuto)
+                {
+                    Vector3 posAdjusted = m_pos + HEAD_ADJUSTMENT;
+                    m_scene.PhysicsScene.RaycastWorld(m_pos, Vector3.Normalize(CameraPosition - posAdjusted), Vector3.Distance(CameraPosition, posAdjusted) + 0.3f, RayCastCameraCallback);
+                }
+            }
+            TriggerScenePresenceUpdated();
+        }
+        
        /// <summary>
        /// Calculate an update to move the presence to the set target.
        /// </summary>
@@ -2252,17 +2499,13 @@ namespace OpenSim.Region.Framework.Scenes
        {
 //            m_log.DebugFormat("[SCENE PRESENCE]: StandUp() for {0}", Name);
+            bool satOnObject = IsSatOnObject;
+            SceneObjectPart part = ParentPart;
            SitGround = false;
-/* move this down so avatar gets physical in the new position and not where it is siting
+            if (satOnObject)
-            if (PhysicsActor == null)
-                AddToPhysicalScene(false);
- */
-            if (ParentID != 0)
            {
                PrevSitOffset = m_pos; // Save sit offset
-                SceneObjectPart part = ParentPart;
                UnRegisterSeatControls(part.ParentGroup.UUID);
                TaskInventoryDictionary taskIDict = part.TaskInventory;
@@ -2281,34 +2524,71 @@ namespace OpenSim.Region.Framework.Scenes
                }
                part.ParentGroup.DeleteAvatar(UUID);
-//                ParentPosition = part.GetWorldPosition();
+                Vector3 sitPartWorldPosition = part.GetWorldPosition();
                ControllingClient.SendClearFollowCamProperties(part.ParentUUID);
-//                m_pos += ParentPosition + new Vector3(0.0f, 0.0f, 2.0f * m_sitAvatarHeight);
-//                ParentPosition = Vector3.Zero;
-                m_pos = part.AbsolutePosition + (m_pos * part.GetWorldRotation()) + new Vector3(0.0f, 0.0f, 2.0f * m_sitAvatarHeight);
-                if (part.SitTargetAvatar == UUID)
-                    m_bodyRot = part.GetWorldRotation() * part.SitTargetOrientation;
                ParentID = 0;
                ParentPart = null;
-                if (PhysicsActor == null)
+                Quaternion standRotation;
-                    AddToPhysicalScene(false);
+                if (part.SitTargetAvatar == UUID)
+                {
+                    standRotation = part.GetWorldRotation();
+                    if (!part.IsRoot)
+                        standRotation = standRotation * part.SitTargetOrientation;
+//                        standRotation = part.RotationOffset * part.SitTargetOrientation;
+//                    else
+//                        standRotation = part.SitTargetOrientation;
+                }
+                else
+                {
+                    standRotation = Rotation;
+                }
+                //Vector3 standPos = ParentPosition + new Vector3(0.0f, 0.0f, 2.0f * m_sitAvatarHeight);
+                //Vector3 standPos = ParentPosition;
+//                Vector3 standPositionAdjustment 
+//                    = part.SitTargetPosition + new Vector3(0.5f, 0f, m_sitAvatarHeight / 2f);
+                Vector3 adjustmentForSitPosition = part.SitTargetPosition * part.GetWorldRotation();
+                // XXX: This is based on the physics capsule sizes.  Need to find a better way to read this rather than
+                // hardcoding here.
+                Vector3 adjustmentForSitPose = new Vector3(0.74f, 0f, 0f) * standRotation;
+                Vector3 standPos = sitPartWorldPosition + adjustmentForSitPosition + adjustmentForSitPose;
+//                m_log.DebugFormat(
+//                    "[SCENE PRESENCE]: Setting stand to pos {0}, (adjustmentForSitPosition {1}, adjustmentForSitPose {2}) rotation {3} for {4} in {5}", 
+//                    standPos, adjustmentForSitPosition, adjustmentForSitPose, standRotation, Name, Scene.Name);
+                Rotation = standRotation;
+                AbsolutePosition = standPos;
+            }
+            // We need to wait until we have calculated proper stand positions before sitting up the physical 
+            // avatar to avoid race conditions.
+            if (PhysicsActor == null)
+                AddToPhysicalScene(false);
+            if (satOnObject)
+            {
                SendAvatarDataToAllAgents();
                m_requestedSitTargetID = 0;
                part.RemoveSittingAvatar(UUID);
-                if (part != null)
+                part.ParentGroup.TriggerScriptChangedEvent(Changed.LINK);
-                    part.ParentGroup.TriggerScriptChangedEvent(Changed.LINK);
            }
            else if (PhysicsActor == null)
                AddToPhysicalScene(false);
            Animator.TrySetMovementAnimation("STAND");
+            TriggerScenePresenceUpdated();
        }
        private SceneObjectPart FindNextAvailableSitTarget(UUID targetID)
@@ -2359,7 +2639,6 @@ namespace OpenSim.Region.Framework.Scenes
                m_sitAvatarHeight = PhysicsActor.Size.Z * 0.5f;
            bool canSit = false;
-            Vector3 pos = part.AbsolutePosition + offset;
            if (part.IsSitTargetSet && part.SitTargetAvatar == UUID.Zero)
            {
@@ -2369,6 +2648,17 @@ namespace OpenSim.Region.Framework.Scenes
                offset = part.SitTargetPosition;
                sitOrientation = part.SitTargetOrientation;
+                if (!part.IsRoot)
+                {
+                    //                m_log.DebugFormat("Old sit orient {0}", sitOrientation);
+                    sitOrientation = part.RotationOffset * sitOrientation;
+                    //                m_log.DebugFormat("New sit orient {0}", sitOrientation);
+//                m_log.DebugFormat("Old sit offset {0}", offset);
+                    offset = offset * part.RotationOffset;
+//                m_log.DebugFormat("New sit offset {0}", offset);
+                }
                canSit = true;
            }
            else
@@ -2376,9 +2666,10 @@ namespace OpenSim.Region.Framework.Scenes
                if (PhysicsSit(part,offset)) // physics engine 
                    return;
+                Vector3 pos = part.AbsolutePosition + offset;
                if (Util.GetDistanceTo(AbsolutePosition, pos) <= 10)
                {
                    AbsolutePosition = pos + new Vector3(0.0f, 0.0f, m_sitAvatarHeight);
                    canSit = true;
                }
@@ -2404,10 +2695,14 @@ namespace OpenSim.Region.Framework.Scenes
                cameraEyeOffset = part.GetCameraEyeOffset();
                forceMouselook = part.GetForceMouselook();
+                // An viewer expects to specify sit positions as offsets to the root prim, even if a child prim is
+                // being sat upon.
+                offset += part.OffsetPosition;
                ControllingClient.SendSitResponse(
-                    part.UUID, offset, sitOrientation, false, cameraAtOffset, cameraEyeOffset, forceMouselook);
+                    part.ParentGroup.UUID, offset, sitOrientation, false, cameraAtOffset, cameraEyeOffset, forceMouselook);
-                m_requestedSitTargetUUID = targetID;
+                m_requestedSitTargetUUID = part.UUID;
                HandleAgentSit(ControllingClient, UUID);
@@ -2435,7 +2730,7 @@ namespace OpenSim.Region.Framework.Scenes
            if (part != null)
            {
                m_requestedSitTargetID = part.LocalId;
-                m_requestedSitTargetUUID = targetID;
+                m_requestedSitTargetUUID = part.UUID;
            }
            else
@@ -2554,6 +2849,9 @@ namespace OpenSim.Region.Framework.Scenes
        public void HandleAgentSit(IClientAPI remoteClient, UUID agentID)
        {
+            if (IsChildAgent)
+                return;
            SceneObjectPart part = m_scene.GetSceneObjectPart(m_requestedSitTargetID);
            if (part != null)
@@ -2603,24 +2901,40 @@ namespace OpenSim.Region.Framework.Scenes
                    Vector3 up = new Vector3((float)x, (float)y, (float)z);
                    Vector3 sitOffset = up * Appearance.AvatarHeight * 0.02638f;
-                    m_pos = sitTargetPos + sitOffset + SIT_TARGET_ADJUSTMENT;
+                    Vector3 newPos = sitTargetPos + sitOffset + SIT_TARGET_ADJUSTMENT;
+                    Quaternion newRot;
+                    if (part.IsRoot)
+                    {
+                        newRot = sitTargetOrient;
+                    }
+                    else
+                    {
+                        newPos = newPos * part.RotationOffset;
+                        newRot = part.RotationOffset * sitTargetOrient;
+                    }
+                    newPos += part.OffsetPosition;
+                    m_pos = newPos;
+                    Rotation = newRot;
-//                    m_pos = sitTargetPos + SIT_TARGET_ADJUSTMENT - sitOffset;
-                    Rotation = sitTargetOrient;
 //                    ParentPosition = part.AbsolutePosition;
-                    part.ParentGroup.AddAvatar(UUID);
                }
                else
                {
-                    m_pos -= part.AbsolutePosition;
+                    // An viewer expects to specify sit positions as offsets to the root prim, even if a child prim is
+                    // being sat upon.
+                    m_pos -= part.GroupPosition;
 //                    ParentPosition = part.AbsolutePosition;
-                    part.ParentGroup.AddAvatar(UUID);
 //                        m_log.DebugFormat(
 //                            "[SCENE PRESENCE]: Sitting {0} at position {1} ({2} + {3}) on part {4} {5} without sit target",
 //                            Name, part.AbsolutePosition, m_pos, ParentPosition, part.Name, part.LocalId);
                }
+                part.ParentGroup.AddAvatar(UUID);
                ParentPart = m_scene.GetSceneObjectPart(m_requestedSitTargetID);
                ParentID = m_requestedSitTargetID;
                m_AngularVelocity = Vector3.Zero;
@@ -2634,14 +2948,19 @@ namespace OpenSim.Region.Framework.Scenes
                }
                Animator.TrySetMovementAnimation(sitAnimation);
                SendAvatarDataToAllAgents();
+                TriggerScenePresenceUpdated();
            }
        }
        public void HandleAgentSitOnGround()
        {
+            if (IsChildAgent)
+                return;
 //            m_updateCount = 0;  // Kill animation update burst so that the SIT_G.. will stick..
            m_AngularVelocity = Vector3.Zero;
            Animator.TrySetMovementAnimation("SIT_GROUND_CONSTRAINED");
+            TriggerScenePresenceUpdated();
            SitGround = true;
            RemoveFromPhysicalScene();
        }
@@ -2658,11 +2977,13 @@ namespace OpenSim.Region.Framework.Scenes
        public void HandleStartAnim(IClientAPI remoteClient, UUID animID)
        {
            Animator.AddAnimation(animID, UUID.Zero);
+            TriggerScenePresenceUpdated();
        }
        public void HandleStopAnim(IClientAPI remoteClient, UUID animID)
        {
            Animator.RemoveAnimation(animID, false);
+            TriggerScenePresenceUpdated();
        }
        public void avnHandleChangeAnim(UUID animID, bool addRemove,bool sendPack)
@@ -2676,10 +2997,13 @@ namespace OpenSim.Region.Framework.Scenes
        /// Rotate the avatar to the given rotation and apply a movement in the given relative vector
        /// </summary>
        /// <param name="vec">The vector in which to move.  This is relative to the rotation argument</param>
-        public void AddNewMovement(Vector3 vec)
+        /// <param name="thisAddSpeedModifier">
+        /// Optional additional speed modifier for this particular add.  Default is 1</param>
+        public void AddNewMovement(Vector3 vec, float thisAddSpeedModifier = 1)
        {
 //            m_log.DebugFormat(
-//                "[SCENE PRESENCE]: Adding new movement {0} with rotation {1} for {2}", vec, Rotation, Name);
+//                "[SCENE PRESENCE]: Adding new movement {0} with rotation {1}, thisAddSpeedModifier {2} for {3}", 
+//                vec, Rotation, thisAddSpeedModifier, Name);
            Vector3 direc = vec * Rotation;
            direc.Normalize();
@@ -2697,7 +3021,7 @@ namespace OpenSim.Region.Framework.Scenes
            if ((vec.Z == 0f) && !Flying)
                direc.Z = 0f; // Prevent camera WASD up.
-            direc *= 0.03f * 128f * SpeedModifier;
+            direc *= 0.03f * 128f * SpeedModifier * thisAddSpeedModifier;
 //            m_log.DebugFormat("[SCENE PRESENCE]: Force to apply before modification was {0} for {1}", direc, Name);
@@ -2843,6 +3167,7 @@ namespace OpenSim.Region.Framework.Scenes
                lastTerseUpdateToAllClientsTick = currentTick;
                lastPositionSentToAllClients = OffsetPosition;
+//                Console.WriteLine("Scheduled update for {0} in {1}", Name, Scene.Name);
                m_scene.ForEachClient(SendTerseUpdateToClient);
            }
            TriggerScenePresenceUpdated();
@@ -2880,11 +3205,12 @@ namespace OpenSim.Region.Framework.Scenes
                SendOtherAgentsAppearanceToMe();
                EntityBase[] entities = Scene.Entities.GetEntities();
-                foreach(EntityBase e in entities)
+                foreach (EntityBase e in entities)
                {
                    if (e != null && e is SceneObjectGroup)
                        ((SceneObjectGroup)e).SendFullUpdateToClient(ControllingClient);
                }
            });
        }
@@ -2919,12 +3245,14 @@ namespace OpenSim.Region.Framework.Scenes
            // again here... this comes after the cached appearance check because the avatars
            // appearance goes into the avatar update packet
            SendAvatarDataToAllAgents();
+            // This invocation always shows up in the viewer logs as an error.  Is it needed?
            SendAppearanceToAgent(this);
            // If we are using the the cached appearance then send it out to everyone
            if (cachedappearance)
            {
-                m_log.DebugFormat("[SCENE PRESENCE]: baked textures are in the cache for {0}", Name);
+                m_log.DebugFormat("[SCENE PRESENCE]: Baked textures are in the cache for {0} in {1}", Name, m_scene.Name);
                // If the avatars baked textures are all in the cache, then we have a 
                // complete appearance... send it out, if not, then we'll send it when
@@ -3079,11 +3407,10 @@ namespace OpenSim.Region.Framework.Scenes
            }
            // Minimum Draw distance is 64 meters, the Radius of the draw distance sphere is 32m
-            if (Util.GetDistanceTo(AbsolutePosition, m_lastChildAgentUpdatePosition) >= Scene.ChildReprioritizationDistance ||
+            if (Util.GetDistanceTo(AbsolutePosition, m_lastChildAgentUpdatePosition) >= Scene.ChildReprioritizationDistance)
-                Util.GetDistanceTo(CameraPosition, m_lastChildAgentUpdateCamPosition) >= Scene.ChildReprioritizationDistance)
            {
                m_lastChildAgentUpdatePosition = AbsolutePosition;
-                m_lastChildAgentUpdateCamPosition = CameraPosition;
+//                m_lastChildAgentUpdateCamPosition = CameraPosition;
                ChildAgentDataUpdate cadu = new ChildAgentDataUpdate();
                cadu.ActiveGroupID = UUID.Zero.Guid;
@@ -3110,7 +3437,7 @@ namespace OpenSim.Region.Framework.Scenes
                cadu.Velocity = Velocity;
                AgentPosition agentpos = new AgentPosition();
-                agentpos.CopyFrom(cadu);
+                agentpos.CopyFrom(cadu, ControllingClient.SessionId);
                // Let's get this out of the update loop
                Util.FireAndForget(delegate { m_scene.SendOutChildAgentUpdates(agentpos, this); });
@@ -3294,11 +3621,6 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
-        public void RestoreInCurrentScene()
-        {
-            AddToPhysicalScene(false); // not exactly false
-        }
        public void Reset()
        {
 //            m_log.DebugFormat("[SCENE PRESENCE]: Resetting {0} in {1}", Name, Scene.RegionInfo.RegionName);
@@ -3348,10 +3670,12 @@ namespace OpenSim.Region.Framework.Scenes
            if (byebyeRegions.Count > 0)
            {
                m_log.Debug("[SCENE PRESENCE]: Closing " + byebyeRegions.Count + " child agents");
-                Util.FireAndForget(delegate 
-                { 
+                AgentCircuitData acd = Scene.AuthenticateHandler.GetAgentCircuitData(UUID);
-                    m_scene.SceneGridService.SendCloseChildAgentConnections(ControllingClient.AgentId, byebyeRegions); 
+                string auth = string.Empty;
-                });
+                if (acd != null)
+                    auth = acd.SessionID.ToString();
+                m_scene.SceneGridService.SendCloseChildAgentConnections(ControllingClient.AgentId, auth, byebyeRegions); 
            }
            
            foreach (ulong handle in byebyeRegions)
@@ -3392,7 +3716,7 @@ namespace OpenSim.Region.Framework.Scenes
        #region Child Agent Updates
-        public void ChildAgentDataUpdate(AgentData cAgentData)
+        public void UpdateChildAgent(AgentData cAgentData)
        {
 //            m_log.Debug("   >>> ChildAgentDataUpdate <<< " + Scene.RegionInfo.RegionName);
            if (!IsChildAgent)
@@ -3402,15 +3726,17 @@ namespace OpenSim.Region.Framework.Scenes
        }
        private static Vector3 marker = new Vector3(-1f, -1f, -1f);
        private void RaiseUpdateThrottles()
        {
            m_scene.EventManager.TriggerThrottleUpdate(this);
        }
        /// <summary>
        /// This updates important decision making data about a child agent
        /// The main purpose is to figure out what objects to send to a child agent that's in a neighboring region
        /// </summary>
-        public void ChildAgentDataUpdate(AgentPosition cAgentData, uint tRegionX, uint tRegionY, uint rRegionX, uint rRegionY)
+        public void UpdateChildAgent(AgentPosition cAgentData, uint tRegionX, uint tRegionY, uint rRegionX, uint rRegionY)
        {
            if (!IsChildAgent)
                return;
@@ -3452,6 +3778,7 @@ namespace OpenSim.Region.Framework.Scenes
            cAgent.AgentID = UUID;
            cAgent.RegionID = Scene.RegionInfo.RegionID;
+            cAgent.SessionID = ControllingClient.SessionId;
            cAgent.Position = AbsolutePosition;
            cAgent.Velocity = m_velocity;
@@ -3517,7 +3844,8 @@ namespace OpenSim.Region.Framework.Scenes
        private void CopyFrom(AgentData cAgent)
        {
-            m_originRegionID = cAgent.RegionID;
+            lock (m_originRegionIDAccessLock)
+                m_originRegionID = cAgent.RegionID;
            m_callbackURI = cAgent.CallbackURI;
 //            m_log.DebugFormat(
@@ -3611,8 +3939,6 @@ namespace OpenSim.Region.Framework.Scenes
            {
                Vector3 force = m_forceToApply.Value;
-                Updated = true;
                Velocity = force;
                m_forceToApply = null;
@@ -3694,7 +4020,8 @@ namespace OpenSim.Region.Framework.Scenes
 //                if (m_updateCount > 0)
 //                {
-            Animator.UpdateMovementAnimations();
+            if (Animator.UpdateMovementAnimations())
+                TriggerScenePresenceUpdated();
 //                    m_updateCount--;
 //                }
@@ -3858,6 +4185,7 @@ namespace OpenSim.Region.Framework.Scenes
 //                Animator.Close();
            Animator = null;
+            LifecycleState = ScenePresenceState.Removed;
        }
        public void AddAttachment(SceneObjectGroup gobj)
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresenceStateMachine.cs b/OpenSim/Region/Framework/Scenes/ScenePresenceStateMachine.cs
new file mode 100644
index 0000000..cae7fe5
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/ScenePresenceStateMachine.cs
@@ -0,0 +1,113 @@
+/*
+ * 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;
+namespace OpenSim.Region.Framework.Scenes
+{
+    /// <summary>
+    /// The possible states that a scene presence can be in.  This is currently orthagonal to whether a scene presence
+    /// is root or child.
+    /// </summary>
+    /// <remarks>
+    /// This is a state machine.
+    ///
+    /// [Entry]               => Running
+    /// Running               => PreRemove, Removing
+    /// PreRemove             => Running, Removing
+    /// Removing              => Removed
+    /// 
+    /// All other methods should only see the scene presence in running state - this is the normal operational state
+    /// Removed state occurs when the presence has been removed.  This is the end state with no exit.
+    /// </remarks>
+    public enum ScenePresenceState
+    {
+        Running,                // Normal operation state.  The scene presence is available.
+        PreRemove,              // The presence is due to be removed but can still be returning to running.
+        Removing,               // The presence is in the process of being removed from the scene via Scene.RemoveClient.
+        Removed,                // The presence has been removed from the scene and is effectively dead.
+                                // There is no exit from this state.
+    }
+    internal class ScenePresenceStateMachine
+    {
+        private ScenePresence m_sp;
+        private ScenePresenceState m_state;
+        internal ScenePresenceStateMachine(ScenePresence sp)
+        {
+            m_sp = sp;
+            m_state = ScenePresenceState.Running;
+        }
+        internal ScenePresenceState GetState()
+        {
+            return m_state;
+        }
+        /// <summary>
+        /// Updates the state of an agent that is already in transit.
+        /// </summary>
+        /// <param name='id'></param>
+        /// <param name='newState'></param>
+        /// <returns></returns>
+        /// <exception cref='Exception'>Illegal transitions will throw an Exception</exception>
+        internal void SetState(ScenePresenceState newState)
+        {
+            bool transitionOkay = false;
+            lock (this)
+            {
+                if (newState == m_state)
+                    return;
+                else if (newState == ScenePresenceState.Running && m_state == ScenePresenceState.PreRemove)
+                    transitionOkay = true;
+                else if (newState == ScenePresenceState.PreRemove && m_state == ScenePresenceState.Running)
+                    transitionOkay = true;
+                else if (newState == ScenePresenceState.Removing)
+                {   
+                    if (m_state == ScenePresenceState.Running || m_state == ScenePresenceState.PreRemove)
+                        transitionOkay = true;
+                }
+                else if (newState == ScenePresenceState.Removed && m_state == ScenePresenceState.Removing)
+                    transitionOkay = true;
+            }           
+            if (!transitionOkay)
+            {
+                throw new Exception(
+                    string.Format(
+                        "Scene presence {0} is not allowed to move from state {1} to new state {2} in {3}",
+                        m_sp.Name, m_state, newState, m_sp.Scene.Name));
+            }
+            else
+            {
+                m_state = newState;
+            }
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
index ce4fb40..5372360 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -365,6 +365,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
            m_SOPXmlProcessors.Add("CollisionSound", ProcessCollisionSound);
            m_SOPXmlProcessors.Add("CollisionSoundVolume", ProcessCollisionSoundVolume);
            m_SOPXmlProcessors.Add("MediaUrl", ProcessMediaUrl);
+            m_SOPXmlProcessors.Add("AttachedPos", ProcessAttachedPos);
            m_SOPXmlProcessors.Add("DynAttrs", ProcessDynAttrs);
            m_SOPXmlProcessors.Add("TextureAnimation", ProcessTextureAnimation);
            m_SOPXmlProcessors.Add("ParticleSystem", ProcessParticleSystem);
@@ -443,6 +444,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
            m_ShapeXmlProcessors.Add("ProfileEnd", ProcessShpProfileEnd);
            m_ShapeXmlProcessors.Add("ProfileHollow", ProcessShpProfileHollow);
            m_ShapeXmlProcessors.Add("Scale", ProcessShpScale);
+            m_ShapeXmlProcessors.Add("LastAttachPoint", ProcessShpLastAttach);
            m_ShapeXmlProcessors.Add("State", ProcessShpState);
            m_ShapeXmlProcessors.Add("ProfileShape", ProcessShpProfileShape);
            m_ShapeXmlProcessors.Add("HollowShape", ProcessShpHollowShape);
@@ -798,6 +800,11 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
            obj.MediaUrl = reader.ReadElementContentAsString("MediaUrl", String.Empty);
        }
+        private static void ProcessAttachedPos(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.AttachedPos = Util.ReadVector(reader, "AttachedPos");
+        }
        private static void ProcessDynAttrs(SceneObjectPart obj, XmlTextReader reader)
        {
            obj.DynAttrs.ReadXml(reader);
@@ -1099,6 +1106,11 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
            shp.State = (byte)reader.ReadElementContentAsInt("State", String.Empty);
        }
+        private static void ProcessShpLastAttach(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LastAttachPoint = (byte)reader.ReadElementContentAsInt("LastAttachPoint", String.Empty);
+        }
        private static void ProcessShpProfileShape(PrimitiveBaseShape shp, XmlTextReader reader)
        {
            shp.ProfileShape = Util.ReadEnum<ProfileShape>(reader, "ProfileShape");
@@ -1267,7 +1279,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
            WriteUUID(writer, "CreatorID", sop.CreatorID, options);
-            if (sop.CreatorData != null && sop.CreatorData != string.Empty)
+            if (!string.IsNullOrEmpty(sop.CreatorData))
                writer.WriteElementString("CreatorData", sop.CreatorData);
            else if (options.ContainsKey("home"))
            {
@@ -1345,8 +1357,9 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
            writer.WriteElementString("CollisionSoundVolume", sop.CollisionSoundVolume.ToString());
            if (sop.MediaUrl != null)
                writer.WriteElementString("MediaUrl", sop.MediaUrl.ToString());
+            WriteVector(writer, "AttachedPos", sop.AttachedPos);
            
-            if (sop.DynAttrs.Count > 0)
+            if (sop.DynAttrs.CountNamespaces > 0)
            {
                writer.WriteStartElement("DynAttrs");
                sop.DynAttrs.WriteXml(writer);
@@ -1451,7 +1464,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                    WriteUUID(writer, "CreatorID", item.CreatorID, options);
-                    if (item.CreatorData != null && item.CreatorData != string.Empty)
+                    if (!string.IsNullOrEmpty(item.CreatorData))
                        writer.WriteElementString("CreatorData", item.CreatorData);
                    else if (options.ContainsKey("home"))
                    {
@@ -1539,6 +1552,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                writer.WriteElementString("ProfileEnd", shp.ProfileEnd.ToString());
                writer.WriteElementString("ProfileHollow", shp.ProfileHollow.ToString());
                writer.WriteElementString("State", shp.State.ToString());
+                writer.WriteElementString("LastAttachPoint", shp.LastAttachPoint.ToString());
                WriteFlags(writer, "ProfileShape", shp.ProfileShape.ToString(), options);
                WriteFlags(writer, "HollowShape", shp.HollowShape.ToString(), options);
diff --git a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
index 5398ab9..bf32251 100644
--- a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
+++ b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
@@ -290,6 +290,9 @@ namespace OpenSim.Region.Framework.Scenes
        private void statsHeartBeat(object sender, EventArgs e)
        {
+            if (!m_scene.Active)
+                return;
            SimStatsPacket.StatBlock[] sb = new SimStatsPacket.StatBlock[23];
            SimStatsPacket.RegionBlock rb = new SimStatsPacket.RegionBlock();
            
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
index 9557cd0..95b30d5 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
@@ -33,7 +33,9 @@ using NUnit.Framework;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Framework.Communications;
+using OpenSim.Region.CoreModules.Framework.EntityTransfer;
 using OpenSim.Region.CoreModules.Framework.InventoryAccess;
+using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
 using OpenSim.Region.CoreModules.World.Permissions;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
@@ -52,6 +54,24 @@ namespace OpenSim.Region.Framework.Scenes.Tests
    [TestFixture]
    public class SceneObjectDeRezTests : OpenSimTestCase
    {
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            // This facility was added after the original async delete tests were written, so it may be possible now
+            // to not bother explicitly disabling their async (since everything will be running sync).
+            Util.FireAndForgetMethod = FireAndForgetMethod.RegressionTest;
+        }
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            // We must set this back afterwards, otherwise later tests will fail since they're expecting multiple
+            // threads.  Possibly, later tests should be rewritten so none of them require async stuff (which regression
+            // tests really shouldn't).
+            Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
+        }
        /// <summary>
        /// Test deleting an object from a scene.
        /// </summary>
@@ -59,7 +79,6 @@ namespace OpenSim.Region.Framework.Scenes.Tests
        public void TestDeRezSceneObject()
        {
            TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
                        
            UUID userId = UUID.Parse("10000000-0000-0000-0000-000000000001");
            
@@ -73,32 +92,77 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            // Turn off the timer on the async sog deleter - we'll crank it by hand for this test.
            AsyncSceneObjectGroupDeleter sogd = scene.SceneObjectGroupDeleter;
            sogd.Enabled = false;            
-            
-            SceneObjectPart part
+            SceneObjectGroup so = SceneHelpers.AddSceneObject(scene, "so1", userId);
-                = new SceneObjectPart(userId, PrimitiveBaseShape.Default, Vector3.Zero, Quaternion.Identity, Vector3.Zero);
+            uint soLocalId = so.LocalId;
-            part.Name = "obj1";
-            scene.AddNewSceneObject(new SceneObjectGroup(part), false);
            List<uint> localIds = new List<uint>();
-            localIds.Add(part.LocalId);
+            localIds.Add(so.LocalId);
            scene.DeRezObjects(client, localIds, UUID.Zero, DeRezAction.Delete, UUID.Zero);
            // Check that object isn't deleted until we crank the sogd handle.
-            SceneObjectPart retrievedPart = scene.GetSceneObjectPart(part.LocalId);
+            SceneObjectPart retrievedPart = scene.GetSceneObjectPart(so.LocalId);
            Assert.That(retrievedPart, Is.Not.Null);
            Assert.That(retrievedPart.ParentGroup.IsDeleted, Is.False);
            sogd.InventoryDeQueueAndDelete();
            
-            SceneObjectPart retrievedPart2 = scene.GetSceneObjectPart(part.LocalId);
+            SceneObjectPart retrievedPart2 = scene.GetSceneObjectPart(so.LocalId);
-            Assert.That(retrievedPart2, Is.Null);
+            Assert.That(retrievedPart2, Is.Null);              
+        }
+        /// <summary>
+        /// Test that child and root agents correctly receive KillObject notifications.
+        /// </summary>
+        [Test]
+        public void TestDeRezSceneObjectToAgents()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1000, 999);
+            // We need this so that the creation of the root client for userB in sceneB can trigger the creation of a child client in sceneA
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
+            EntityTransferModule etmB = new EntityTransferModule();
+            IConfigSource config = new IniConfigSource();
+            IConfig modulesConfig = config.AddConfig("Modules");
+            modulesConfig.Set("EntityTransferModule", etmB.Name);
+            modulesConfig.Set("SimulationServices", lscm.Name);
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+            SceneHelpers.SetupSceneModules(sceneB, config, etmB);
+            // We need this for derez
+            //SceneHelpers.SetupSceneModules(sceneA, new PermissionsModule());
+            UserAccount uaA = UserAccountHelpers.CreateUserWithInventory(sceneA, "Andy", "AAA", 0x1, "");
+            UserAccount uaB = UserAccountHelpers.CreateUserWithInventory(sceneA, "Brian", "BBB", 0x2, "");
+            TestClient clientA = (TestClient)SceneHelpers.AddScenePresence(sceneA, uaA).ControllingClient;
+            // This is the more long-winded route we have to take to get a child client created for userB in sceneA
+            // rather than just calling AddScenePresence() as for userA
+            AgentCircuitData acd = SceneHelpers.GenerateAgentData(uaB);
+            TestClient clientB = new TestClient(acd, sceneB);
+            List<TestClient> childClientsB = new List<TestClient>();
+            EntityTransferHelpers.SetupInformClientOfNeighbourTriggersNeighbourClientCreate(clientB, childClientsB);
+            SceneHelpers.AddScenePresence(sceneB, clientB, acd);
+            SceneObjectGroup so = SceneHelpers.AddSceneObject(sceneA);
+            uint soLocalId = so.LocalId;
+            sceneA.DeleteSceneObject(so, false);
        }
        
        /// <summary>
        /// Test deleting an object from a scene where the deleter is not the owner
        /// </summary>
-        /// 
+        /// <remarks>
        /// This test assumes that the deleter is not a god.       
+        /// </remarks>
        [Test]
        public void TestDeRezSceneObjectNotOwner()
        {
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
index bbfbbfc..1ff1329 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
@@ -111,6 +111,45 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Assert.That(scene.GetScenePresences().Count, Is.EqualTo(1));
        }
+        /// <summary>
+        /// Test that duplicate complete movement calls are ignored.
+        /// </summary>
+        /// <remarks>
+        /// If duplicate calls are not ignored then there is a risk of race conditions or other unexpected effects.
+        /// </remarks>
+        [Test]
+        public void TestDupeCompleteMovementCalls()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            UUID spUuid = TestHelpers.ParseTail(0x1);
+            TestScene scene = new SceneHelpers().SetupScene();
+            int makeRootAgentEvents = 0;
+            scene.EventManager.OnMakeRootAgent += spi => makeRootAgentEvents++;
+            ScenePresence sp = SceneHelpers.AddScenePresence(scene, spUuid);
+            Assert.That(makeRootAgentEvents, Is.EqualTo(1));
+            // Normally these would be invoked by a CompleteMovement message coming in to the UDP stack.  But for
+            // convenience, here we will invoke it manually.
+            sp.CompleteMovement(sp.ControllingClient, true);
+            Assert.That(makeRootAgentEvents, Is.EqualTo(1));
+            // Check rest of exepcted parameters.
+            Assert.That(scene.AuthenticateHandler.GetAgentCircuitData(spUuid), Is.Not.Null);
+            Assert.That(scene.AuthenticateHandler.GetAgentCircuits().Count, Is.EqualTo(1));
+          
+            Assert.That(sp.IsChildAgent, Is.False);
+            Assert.That(sp.UUID, Is.EqualTo(spUuid));
+            Assert.That(scene.GetScenePresences().Count, Is.EqualTo(1));
+        }
        [Test]
        public void TestCreateDuplicateRootScenePresence()
        {
@@ -119,7 +158,20 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            UUID spUuid = TestHelpers.ParseTail(0x1);
+            // The etm is only invoked by this test to check whether an agent is still in transit if there is a dupe
+            EntityTransferModule etm = new EntityTransferModule();
+            IConfigSource config = new IniConfigSource();
+            IConfig modulesConfig = config.AddConfig("Modules");
+            modulesConfig.Set("EntityTransferModule", etm.Name);
+            IConfig entityTransferConfig = config.AddConfig("EntityTransfer");
+            // In order to run a single threaded regression test we do not want the entity transfer module waiting
+            // for a callback from the destination scene before removing its avatar data.
+            entityTransferConfig.Set("wait_for_callback", false);
            TestScene scene = new SceneHelpers().SetupScene();
+            SceneHelpers.SetupSceneModules(scene, config, etm);
            SceneHelpers.AddScenePresence(scene, spUuid);
            SceneHelpers.AddScenePresence(scene, spUuid);
@@ -133,7 +185,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
        }
        [Test]
-        public void TestCloseAgent()
+        public void TestCloseClient()
        {
            TestHelpers.InMethod();
 //            TestHelpers.EnableLogging();
@@ -141,7 +193,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            TestScene scene = new SceneHelpers().SetupScene();
            ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x1));
-            scene.IncomingCloseAgent(sp.UUID, false);
+            scene.CloseAgent(sp.UUID, false);
            Assert.That(scene.GetScenePresence(sp.UUID), Is.Null);
            Assert.That(scene.AuthenticateHandler.GetAgentCircuitData(sp.UUID), Is.Null);
@@ -187,7 +239,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            // *** This is the second stage, where the client established a child agent/scene presence using the
            // circuit code given to the scene in stage 1 ***
            TestClient client = new TestClient(acd, scene);
-            scene.AddNewClient(client, PresenceType.User);
+            scene.AddNewAgent(client, PresenceType.User);
            Assert.That(scene.AuthenticateHandler.GetAgentCircuitData(agentId), Is.Not.Null);
            Assert.That(scene.AuthenticateHandler.GetAgentCircuits().Count, Is.EqualTo(1));
@@ -236,58 +288,5 @@ namespace OpenSim.Region.Framework.Scenes.Tests
 //            Assert.That(childPresence, Is.Not.Null);
 //            Assert.That(childPresence.IsChildAgent, Is.True);
        }
-//        /// <summary>
-//        /// Test adding a root agent to a scene.  Doesn't yet actually complete crossing the agent into the scene.
-//        /// </summary>
-//        [Test]
-//        public void T010_TestAddRootAgent()
-//        {
-//            TestHelpers.InMethod();
-//
-//            string firstName = "testfirstname";
-//
-//            AgentCircuitData agent = new AgentCircuitData();
-//            agent.AgentID = agent1;
-//            agent.firstname = firstName;
-//            agent.lastname = "testlastname";
-//            agent.SessionID = UUID.Random();
-//            agent.SecureSessionID = UUID.Random();
-//            agent.circuitcode = 123;
-//            agent.BaseFolder = UUID.Zero;
-//            agent.InventoryFolder = UUID.Zero;
-//            agent.startpos = Vector3.Zero;
-//            agent.CapsPath = GetRandomCapsObjectPath();
-//            agent.ChildrenCapSeeds = new Dictionary<ulong, string>();
-//            agent.child = true;
-//
-//            scene.PresenceService.LoginAgent(agent.AgentID.ToString(), agent.SessionID, agent.SecureSessionID);
-//
-//            string reason;
-//            scene.NewUserConnection(agent, (uint)TeleportFlags.ViaLogin, out reason);
-//            testclient = new TestClient(agent, scene);
-//            scene.AddNewClient(testclient);
-//
-//            ScenePresence presence = scene.GetScenePresence(agent1);
-//
-//            Assert.That(presence, Is.Not.Null, "presence is null");
-//            Assert.That(presence.Firstname, Is.EqualTo(firstName), "First name not same");
-//            acd1 = agent;
-//        }
-//
-//        /// <summary>
-//        /// Test removing an uncrossed root agent from a scene.
-//        /// </summary>
-//        [Test]
-//        public void T011_TestRemoveRootAgent()
-//        {
-//            TestHelpers.InMethod();
-//
-//            scene.RemoveClient(agent1);
-//
-//            ScenePresence presence = scene.GetScenePresence(agent1);
-//
-//            Assert.That(presence, Is.Null, "presence is not null");
-//        }
    }
 }
 \ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCapabilityTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCapabilityTests.cs
new file mode 100644
index 0000000..9fa0a71
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCapabilityTests.cs
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Timers;
+using Timer = System.Timers.Timer;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.ClientStack.Linden;
+using OpenSim.Region.CoreModules.Framework;
+using OpenSim.Region.CoreModules.Framework.EntityTransfer;
+using OpenSim.Region.CoreModules.World.Serialiser;
+using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Tests.Common;
+using OpenSim.Tests.Common.Mock;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+namespace OpenSim.Region.Framework.Scenes.Tests
+{
+    [TestFixture]
+    public class ScenePresenceCapabilityTests : OpenSimTestCase
+    {
+        [Test]
+        public void TestChildAgentSingleRegionCapabilities()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            UUID spUuid = TestHelpers.ParseTail(0x1);
+            // XXX: This is not great since the use of statics will mean that this has to be manually cleaned up for
+            // any subsequent test.
+            // XXX: May replace with a mock IHttpServer later.
+            BaseHttpServer httpServer = new BaseHttpServer(99999);
+            MainServer.AddHttpServer(httpServer);
+            MainServer.Instance = httpServer;
+            CapabilitiesModule capsMod = new CapabilitiesModule();
+            TestScene scene = new SceneHelpers().SetupScene();
+            SceneHelpers.SetupSceneModules(scene, capsMod);
+            ScenePresence sp = SceneHelpers.AddChildScenePresence(scene, spUuid);
+            //Assert.That(capsMod.GetCapsForUser(spUuid), Is.Not.Null);
+            // TODO: Need to add tests for other ICapabiltiesModule methods.
+//            scene.IncomingCloseAgent(sp.UUID, false);
+//            //Assert.That(capsMod.GetCapsForUser(spUuid), Is.Null);
+            scene.CloseAgent(sp.UUID, false);
+//            Assert.That(capsMod.GetCapsForUser(spUuid), Is.Null);
+            // TODO: Need to add tests for other ICapabiltiesModule methods.
+        }
+    }
+}
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCrossingTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCrossingTests.cs
index 8775949..b806a97 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCrossingTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceCrossingTests.cs
@@ -38,6 +38,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.CoreModules.Framework;
 using OpenSim.Region.CoreModules.Framework.EntityTransfer;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
+using OpenSim.Region.CoreModules.World.Permissions;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
@@ -95,11 +96,11 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            SceneHelpers.SetupSceneModules(sceneB, config, new CapabilitiesModule(), etmB);
            AgentCircuitData acd = SceneHelpers.GenerateAgentData(userId);
-            TestClient tc = new TestClient(acd, sceneA, sh.SceneManager);
+            TestClient tc = new TestClient(acd, sceneA);
            List<TestClient> destinationTestClients = new List<TestClient>();
-            EntityTransferHelpers.SetUpInformClientOfNeighbour(tc, destinationTestClients);
+            EntityTransferHelpers.SetupInformClientOfNeighbourTriggersNeighbourClientCreate(tc, destinationTestClients);
-            ScenePresence originalSp = SceneHelpers.AddScenePresence(sceneA, tc, acd, sh.SceneManager);
+            ScenePresence originalSp = SceneHelpers.AddScenePresence(sceneA, tc, acd);
            originalSp.AbsolutePosition = new Vector3(128, 32, 10);
 //            originalSp.Flying = true;
@@ -112,6 +113,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            //moveArgs.BodyRotation = Quaternion.CreateFromEulers(Vector3.Zero);
            moveArgs.BodyRotation = Quaternion.CreateFromEulers(new Vector3(0, 0, (float)-(Math.PI / 2)));
            moveArgs.ControlFlags = (uint)AgentManager.ControlFlags.AGENT_CONTROL_AT_POS;
+            moveArgs.SessionID = acd.SessionID;
            originalSp.HandleAgentUpdate(originalSp.ControllingClient, moveArgs);
@@ -158,5 +160,90 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Assert.That(agentMovementCompleteReceived, Is.EqualTo(1));
            Assert.That(spAfterCrossSceneB.IsChildAgent, Is.False);
        }
+        /// <summary>
+        /// Test a cross attempt where the user can see into the neighbour but does not have permission to become
+        /// root there.
+        /// </summary>
+        [Test]
+        public void TestCrossOnSameSimulatorNoRootDestPerm()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            UUID userId = TestHelpers.ParseTail(0x1);
+            EntityTransferModule etmA = new EntityTransferModule();
+            EntityTransferModule etmB = new EntityTransferModule();
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
+            IConfigSource config = new IniConfigSource();
+            IConfig modulesConfig = config.AddConfig("Modules");
+            modulesConfig.Set("EntityTransferModule", etmA.Name);
+            modulesConfig.Set("SimulationServices", lscm.Name);
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1000, 999);
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+            SceneHelpers.SetupSceneModules(sceneA, config, new CapabilitiesModule(), etmA);
+            // We need to set up the permisions module on scene B so that our later use of agent limit to deny
+            // QueryAccess won't succeed anyway because administrators are always allowed in and the default
+            // IsAdministrator if no permissions module is present is true.
+//            SceneHelpers.SetupSceneModules(sceneB, config, new CapabilitiesModule(), new PermissionsModule(), etmB);
+            AgentCircuitData acd = SceneHelpers.GenerateAgentData(userId);
+            TestClient tc = new TestClient(acd, sceneA);
+            List<TestClient> destinationTestClients = new List<TestClient>();
+            EntityTransferHelpers.SetupInformClientOfNeighbourTriggersNeighbourClientCreate(tc, destinationTestClients);
+            // Make sure sceneB will not accept this avatar.
+            sceneB.RegionInfo.EstateSettings.PublicAccess = false;
+            ScenePresence originalSp = SceneHelpers.AddScenePresence(sceneA, tc, acd);
+            originalSp.AbsolutePosition = new Vector3(128, 32, 10);
+            AgentUpdateArgs moveArgs = new AgentUpdateArgs();
+            //moveArgs.BodyRotation = Quaternion.CreateFromEulers(Vector3.Zero);
+            moveArgs.BodyRotation = Quaternion.CreateFromEulers(new Vector3(0, 0, (float)-(Math.PI / 2)));
+            moveArgs.ControlFlags = (uint)AgentManager.ControlFlags.AGENT_CONTROL_AT_POS;
+            moveArgs.SessionID = acd.SessionID;
+            originalSp.HandleAgentUpdate(originalSp.ControllingClient, moveArgs);
+            sceneA.Update(1);
+//            Console.WriteLine("Second pos {0}", originalSp.AbsolutePosition);
+            // FIXME: This is a sufficient number of updates to for the presence to reach the northern border.
+            // But really we want to do this in a more robust way.
+            for (int i = 0; i < 100; i++)
+            {
+                sceneA.Update(1);
+//                Console.WriteLine("Pos {0}", originalSp.AbsolutePosition);
+            }
+            // sceneA agent should still be root
+            ScenePresence spAfterCrossSceneA = sceneA.GetScenePresence(originalSp.UUID);
+            Assert.That(spAfterCrossSceneA.IsChildAgent, Is.False);
+            ScenePresence spAfterCrossSceneB = sceneB.GetScenePresence(originalSp.UUID);
+            // sceneB agent should also still be root
+            Assert.That(spAfterCrossSceneB.IsChildAgent, Is.True);
+            // sceneB should ignore unauthorized attempt to upgrade agent to root
+            TestClient sceneBTc = ((TestClient)spAfterCrossSceneB.ControllingClient);
+            int agentMovementCompleteReceived = 0;
+            sceneBTc.OnReceivedMoveAgentIntoRegion += (ri, pos, look) => agentMovementCompleteReceived++;
+            sceneBTc.CompleteMovement();
+            Assert.That(agentMovementCompleteReceived, Is.EqualTo(0));
+            Assert.That(spAfterCrossSceneB.IsChildAgent, Is.True);
+        }
    }
-}
-\ No newline at end of file
+}
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs
index acaeb90..0911f00 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceSitTests.cs
@@ -111,15 +111,13 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            SceneObjectPart part = SceneHelpers.AddSceneObject(m_scene).RootPart;
+            // We need to preserve this here because phys actor is removed by the sit.
+            Vector3 spPhysActorSize = m_sp.PhysicsActor.Size;
            m_sp.HandleAgentRequestSit(m_sp.ControllingClient, m_sp.UUID, part.UUID, Vector3.Zero);
-            // FIXME: This is different for live avatars - z position is adjusted.  This is half the height of the
-            // default avatar.
-            // Curiously, Vector3.ToString() will not display the last two places of the float.  For example,
-            // printing out npc.AbsolutePosition will give <0, 0, 0.8454993> not <0, 0, 0.845499337>
            Assert.That(
                m_sp.AbsolutePosition,
-                Is.EqualTo(part.AbsolutePosition + new Vector3(0, 0, 0.845499337f)));
+                Is.EqualTo(part.AbsolutePosition + new Vector3(0, 0, spPhysActorSize.Z / 2)));
            m_sp.StandUp();
@@ -147,9 +145,9 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Assert.That(part.SitTargetAvatar, Is.EqualTo(m_sp.UUID));
            Assert.That(m_sp.ParentID, Is.EqualTo(part.LocalId));
-            Assert.That(
+//            Assert.That(
-                m_sp.AbsolutePosition,
+//                m_sp.AbsolutePosition,
-                Is.EqualTo(part.AbsolutePosition + part.SitTargetPosition + ScenePresence.SIT_TARGET_ADJUSTMENT));
+//                Is.EqualTo(part.AbsolutePosition + part.SitTargetPosition + ScenePresence.SIT_TARGET_ADJUSTMENT));
            Assert.That(m_sp.PhysicsActor, Is.Null);
            Assert.That(part.GetSittingAvatarsCount(), Is.EqualTo(1));
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
index 8d94d29..fff542b 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
@@ -30,6 +30,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Net;
 using System.Text;
+using System.Threading;
 using Nini.Config;
 using NUnit.Framework;
 using OpenMetaverse;
@@ -107,7 +108,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
        }
        [Test]
-        public void TestSameSimulatorIsolatedRegions()
+        public void TestSameSimulatorIsolatedRegionsV1()
        {
            TestHelpers.InMethod();
 //            TestHelpers.EnableLogging();
@@ -136,14 +137,18 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            SceneHelpers.SetupSceneModules(sceneB, config, etmB);
            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+            // FIXME: Hack - this is here temporarily to revert back to older entity transfer behaviour
+            lscm.ServiceVersion = "SIMULATION/0.1";
            Vector3 teleportPosition = new Vector3(10, 11, 12);
            Vector3 teleportLookAt = new Vector3(20, 21, 22);
-            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId, sh.SceneManager);
+            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId);
            sp.AbsolutePosition = new Vector3(30, 31, 32);
            List<TestClient> destinationTestClients = new List<TestClient>();
-            EntityTransferHelpers.SetUpInformClientOfNeighbour((TestClient)sp.ControllingClient, destinationTestClients);
+            EntityTransferHelpers.SetupInformClientOfNeighbourTriggersNeighbourClientCreate(
+                (TestClient)sp.ControllingClient, destinationTestClients);
            sceneA.RequestTeleportLocation(
                sp.ControllingClient,
@@ -176,6 +181,67 @@ namespace OpenSim.Region.Framework.Scenes.Tests
 //            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
        }
+        [Test]
+        public void TestSameSimulatorIsolatedRegionsV2()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            UUID userId = TestHelpers.ParseTail(0x1);
+            EntityTransferModule etmA = new EntityTransferModule();
+            EntityTransferModule etmB = new EntityTransferModule();
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
+            IConfigSource config = new IniConfigSource();
+            IConfig modulesConfig = config.AddConfig("Modules");
+            modulesConfig.Set("EntityTransferModule", etmA.Name);
+            modulesConfig.Set("SimulationServices", lscm.Name);
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1002, 1000);
+            SceneHelpers.SetupSceneModules(sceneA, config, etmA);
+            SceneHelpers.SetupSceneModules(sceneB, config, etmB);
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+            Vector3 teleportPosition = new Vector3(10, 11, 12);
+            Vector3 teleportLookAt = new Vector3(20, 21, 22);
+            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId);
+            sp.AbsolutePosition = new Vector3(30, 31, 32);
+            List<TestClient> destinationTestClients = new List<TestClient>();
+            EntityTransferHelpers.SetupSendRegionTeleportTriggersDestinationClientCreateAndCompleteMovement(
+                (TestClient)sp.ControllingClient, destinationTestClients);
+            sceneA.RequestTeleportLocation(
+                sp.ControllingClient,
+                sceneB.RegionInfo.RegionHandle,
+                teleportPosition,
+                teleportLookAt,
+                (uint)TeleportFlags.ViaLocation);
+            Assert.That(sceneA.GetScenePresence(userId), Is.Null);
+            ScenePresence sceneBSp = sceneB.GetScenePresence(userId);
+            Assert.That(sceneBSp, Is.Not.Null);
+            Assert.That(sceneBSp.Scene.RegionInfo.RegionName, Is.EqualTo(sceneB.RegionInfo.RegionName));
+            Assert.That(sceneBSp.AbsolutePosition, Is.EqualTo(teleportPosition));
+            Assert.That(sceneA.GetRootAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneA.GetChildAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneB.GetRootAgentCount(), Is.EqualTo(1));
+            Assert.That(sceneB.GetChildAgentCount(), Is.EqualTo(0));
+            // TODO: Add assertions to check correct circuit details in both scenes.
+            // Lookat is sent to the client only - sp.Lookat does not yield the same thing (calculation from camera
+            // position instead).
+//            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
+        }
        /// <summary>
        /// Test teleport procedures when the target simulator returns false when queried about access.
        /// </summary>
@@ -224,7 +290,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Vector3 teleportPosition = new Vector3(10, 11, 12);
            Vector3 teleportLookAt = new Vector3(20, 21, 22);
-            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId, sh.SceneManager);
+            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId);
            sp.AbsolutePosition = preTeleportPosition;
            // Make sceneB return false on query access
@@ -300,7 +366,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Vector3 teleportPosition = new Vector3(10, 11, 12);
            Vector3 teleportLookAt = new Vector3(20, 21, 22);
-            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId, sh.SceneManager);
+            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId);
            sp.AbsolutePosition = preTeleportPosition;
            // Make sceneB refuse CreateAgent
@@ -389,7 +455,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            Vector3 teleportPosition = new Vector3(10, 11, 12);
            Vector3 teleportLookAt = new Vector3(20, 21, 22);
-            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId, sh.SceneManager);
+            ScenePresence sp = SceneHelpers.AddScenePresence(sceneA, userId);
            sp.AbsolutePosition = preTeleportPosition;
            sceneA.RequestTeleportLocation(
@@ -425,10 +491,10 @@ namespace OpenSim.Region.Framework.Scenes.Tests
        }
        [Test]
-        public void TestSameSimulatorNeighbouringRegions()
+        public void TestSameSimulatorNeighbouringRegionsV1()
        {
            TestHelpers.InMethod();
-            TestHelpers.EnableLogging();
+//            TestHelpers.EnableLogging();
            UUID userId = TestHelpers.ParseTail(0x1);
@@ -454,15 +520,18 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            SceneHelpers.SetupSceneModules(sceneA, config, new CapabilitiesModule(), etmA);
            SceneHelpers.SetupSceneModules(sceneB, config, new CapabilitiesModule(), etmB);
+            // FIXME: Hack - this is here temporarily to revert back to older entity transfer behaviour
+            lscm.ServiceVersion = "SIMULATION/0.1";
            Vector3 teleportPosition = new Vector3(10, 11, 12);
            Vector3 teleportLookAt = new Vector3(20, 21, 22);
            AgentCircuitData acd = SceneHelpers.GenerateAgentData(userId);
-            TestClient tc = new TestClient(acd, sceneA, sh.SceneManager);
+            TestClient tc = new TestClient(acd, sceneA);
            List<TestClient> destinationTestClients = new List<TestClient>();
-            EntityTransferHelpers.SetUpInformClientOfNeighbour(tc, destinationTestClients);
+            EntityTransferHelpers.SetupInformClientOfNeighbourTriggersNeighbourClientCreate(tc, destinationTestClients);
-            ScenePresence beforeSceneASp = SceneHelpers.AddScenePresence(sceneA, tc, acd, sh.SceneManager);
+            ScenePresence beforeSceneASp = SceneHelpers.AddScenePresence(sceneA, tc, acd);
            beforeSceneASp.AbsolutePosition = new Vector3(30, 31, 32);
            Assert.That(beforeSceneASp, Is.Not.Null);
@@ -506,5 +575,89 @@ namespace OpenSim.Region.Framework.Scenes.Tests
 //            TestHelpers.DisableLogging();
        }
+        [Test]
+        public void TestSameSimulatorNeighbouringRegionsV2()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            UUID userId = TestHelpers.ParseTail(0x1);
+            EntityTransferModule etmA = new EntityTransferModule();
+            EntityTransferModule etmB = new EntityTransferModule();
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
+            IConfigSource config = new IniConfigSource();
+            IConfig modulesConfig = config.AddConfig("Modules");
+            modulesConfig.Set("EntityTransferModule", etmA.Name);
+            modulesConfig.Set("SimulationServices", lscm.Name);
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
+            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1001, 1000);
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+            SceneHelpers.SetupSceneModules(sceneA, config, new CapabilitiesModule(), etmA);
+            SceneHelpers.SetupSceneModules(sceneB, config, new CapabilitiesModule(), etmB);
+            Vector3 teleportPosition = new Vector3(10, 11, 12);
+            Vector3 teleportLookAt = new Vector3(20, 21, 22);
+            AgentCircuitData acd = SceneHelpers.GenerateAgentData(userId);
+            TestClient tc = new TestClient(acd, sceneA);
+            List<TestClient> destinationTestClients = new List<TestClient>();
+            EntityTransferHelpers.SetupInformClientOfNeighbourTriggersNeighbourClientCreate(tc, destinationTestClients);
+            ScenePresence beforeSceneASp = SceneHelpers.AddScenePresence(sceneA, tc, acd);
+            beforeSceneASp.AbsolutePosition = new Vector3(30, 31, 32);
+            Assert.That(beforeSceneASp, Is.Not.Null);
+            Assert.That(beforeSceneASp.IsChildAgent, Is.False);
+            ScenePresence beforeSceneBSp = sceneB.GetScenePresence(userId);
+            Assert.That(beforeSceneBSp, Is.Not.Null);
+            Assert.That(beforeSceneBSp.IsChildAgent, Is.True);
+            // Here, we need to make clientA's receipt of SendRegionTeleport trigger clientB's CompleteMovement().  This
+            // is to operate the teleport V2 mechanism where the EntityTransferModule will first request the client to
+            // CompleteMovement to the region and then call UpdateAgent to the destination region to confirm the receipt
+            // Both these operations will occur on different threads and will wait for each other.
+            // We have to do this via ThreadPool directly since FireAndForget has been switched to sync for the V1
+            // test protocol, where we are trying to avoid unpredictable async operations in regression tests.
+            tc.OnTestClientSendRegionTeleport 
+                += (regionHandle, simAccess, regionExternalEndPoint, locationID, flags, capsURL) 
+                    => ThreadPool.UnsafeQueueUserWorkItem(o => destinationTestClients[0].CompleteMovement(), null);
+            sceneA.RequestTeleportLocation(
+                beforeSceneASp.ControllingClient,
+                sceneB.RegionInfo.RegionHandle,
+                teleportPosition,
+                teleportLookAt,
+                (uint)TeleportFlags.ViaLocation);
+            ScenePresence afterSceneASp = sceneA.GetScenePresence(userId);
+            Assert.That(afterSceneASp, Is.Not.Null);
+            Assert.That(afterSceneASp.IsChildAgent, Is.True);
+            ScenePresence afterSceneBSp = sceneB.GetScenePresence(userId);
+            Assert.That(afterSceneBSp, Is.Not.Null);
+            Assert.That(afterSceneBSp.IsChildAgent, Is.False);
+            Assert.That(afterSceneBSp.Scene.RegionInfo.RegionName, Is.EqualTo(sceneB.RegionInfo.RegionName));
+            Assert.That(afterSceneBSp.AbsolutePosition, Is.EqualTo(teleportPosition));
+            Assert.That(sceneA.GetRootAgentCount(), Is.EqualTo(0));
+            Assert.That(sceneA.GetChildAgentCount(), Is.EqualTo(1));
+            Assert.That(sceneB.GetRootAgentCount(), Is.EqualTo(1));
+            Assert.That(sceneB.GetChildAgentCount(), Is.EqualTo(0));
+            // TODO: Add assertions to check correct circuit details in both scenes.
+            // Lookat is sent to the client only - sp.Lookat does not yield the same thing (calculation from camera
+            // position instead).
+//            Assert.That(sp.Lookat, Is.EqualTo(teleportLookAt));
+//            TestHelpers.DisableLogging();
+        }
    }
 }
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneStatisticsTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneStatisticsTests.cs
new file mode 100644
index 0000000..1667002
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneStatisticsTests.cs
@@ -0,0 +1,71 @@
+/*
+ * 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 NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+using OpenSim.Tests.Common.Mock;
+namespace OpenSim.Region.Framework.Scenes.Tests
+{
+    [TestFixture]
+    public class SceneStatisticsTests : OpenSimTestCase
+    {
+        private TestScene m_scene;
+        [SetUp]
+        public void Init()
+        {
+            m_scene = new SceneHelpers().SetupScene();
+        }
+        [Test]
+        public void TestAddRemovePhysicalLinkset()
+        {
+            Assert.That(m_scene.SceneGraph.GetActiveObjectsCount(), Is.EqualTo(0));
+            UUID ownerId = TestHelpers.ParseTail(0x1);
+            SceneObjectGroup so1 = SceneHelpers.CreateSceneObject(3, ownerId, "so1", 0x10);
+            so1.ScriptSetPhysicsStatus(true);
+            m_scene.AddSceneObject(so1);
+            Assert.That(m_scene.SceneGraph.GetTotalObjectsCount(), Is.EqualTo(3));
+            Assert.That(m_scene.SceneGraph.GetActiveObjectsCount(), Is.EqualTo(3));
+            m_scene.DeleteSceneObject(so1, false);
+            Assert.That(m_scene.SceneGraph.GetTotalObjectsCount(), Is.EqualTo(0));
+            Assert.That(m_scene.SceneGraph.GetActiveObjectsCount(), Is.EqualTo(0));
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneTelehubTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneTelehubTests.cs
new file mode 100644
index 0000000..9a97acc
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneTelehubTests.cs
@@ -0,0 +1,119 @@
+/*
+ * 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 Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.CoreModules.World.Estate;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+using OpenSim.Tests.Common;
+using OpenSim.Tests.Common.Mock;
+namespace OpenSim.Region.Framework.Scenes.Tests
+{
+    /// <summary>
+    /// Scene telehub tests
+    /// </summary>
+    /// <remarks>
+    /// TODO: Tests which run through normal functionality.  Currently, the only test is one that checks behaviour
+    /// in the case of an error condition
+    /// </remarks>
+    [TestFixture]
+    public class SceneTelehubTests : OpenSimTestCase
+    {
+        /// <summary>
+        /// Test for desired behaviour when a telehub has no spawn points
+        /// </summary>
+        [Test]
+        public void TestNoTelehubSpawnPoints()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            EstateManagementModule emm = new EstateManagementModule();
+            SceneHelpers sh = new SceneHelpers();
+            Scene scene = sh.SetupScene();
+            SceneHelpers.SetupSceneModules(scene, emm);
+            UUID telehubSceneObjectOwner = TestHelpers.ParseTail(0x1);
+            SceneObjectGroup telehubSo = SceneHelpers.AddSceneObject(scene, "telehubObject", telehubSceneObjectOwner);
+            emm.HandleOnEstateManageTelehub(null, UUID.Zero, UUID.Zero, "connect", telehubSo.LocalId);
+            scene.RegionInfo.EstateSettings.AllowDirectTeleport = false;
+            // Must still be possible to successfully log in
+            UUID loggingInUserId = TestHelpers.ParseTail(0x2);
+            UserAccount ua 
+                = UserAccountHelpers.CreateUserWithInventory(scene, "Test", "User", loggingInUserId, "password");
+            SceneHelpers.AddScenePresence(scene, ua);
+            Assert.That(scene.GetScenePresence(loggingInUserId), Is.Not.Null);
+        }
+        /// <summary>
+        /// Test for desired behaviour when the scene object nominated as a telehub object does not exist.
+        /// </summary>
+        [Test]
+        public void TestNoTelehubSceneObject()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            EstateManagementModule emm = new EstateManagementModule();
+            SceneHelpers sh = new SceneHelpers();
+            Scene scene = sh.SetupScene();
+            SceneHelpers.SetupSceneModules(scene, emm);
+            UUID telehubSceneObjectOwner = TestHelpers.ParseTail(0x1);
+            SceneObjectGroup telehubSo = SceneHelpers.AddSceneObject(scene, "telehubObject", telehubSceneObjectOwner);
+            SceneObjectGroup spawnPointSo = SceneHelpers.AddSceneObject(scene, "spawnpointObject", telehubSceneObjectOwner);
+            emm.HandleOnEstateManageTelehub(null, UUID.Zero, UUID.Zero, "connect", telehubSo.LocalId);
+            emm.HandleOnEstateManageTelehub(null, UUID.Zero, UUID.Zero, "spawnpoint add", spawnPointSo.LocalId);
+            scene.RegionInfo.EstateSettings.AllowDirectTeleport = false;
+            scene.DeleteSceneObject(telehubSo, false);
+            // Must still be possible to successfully log in
+            UUID loggingInUserId = TestHelpers.ParseTail(0x2);
+            UserAccount ua 
+                = UserAccountHelpers.CreateUserWithInventory(scene, "Test", "User", loggingInUserId, "password");
+            SceneHelpers.AddScenePresence(scene, ua);
+            Assert.That(scene.GetScenePresence(loggingInUserId), Is.Not.Null);
+        }
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs b/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs
index dd27294..1e59e3f 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/UuidGathererTests.cs
@@ -62,8 +62,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
                = AssetHelpers.CreateAsset(corruptAssetUuid, AssetType.Notecard, "CORRUPT ASSET", UUID.Zero);
            m_assetService.Store(corruptAsset);
-            IDictionary<UUID, AssetType> foundAssetUuids = new Dictionary<UUID, AssetType>();
+            IDictionary<UUID, sbyte> foundAssetUuids = new Dictionary<UUID, sbyte>();
-            m_uuidGatherer.GatherAssetUuids(corruptAssetUuid, AssetType.Object, foundAssetUuids);
+            m_uuidGatherer.GatherAssetUuids(corruptAssetUuid, (sbyte)AssetType.Object, foundAssetUuids);
            // We count the uuid as gathered even if the asset itself is corrupt.
            Assert.That(foundAssetUuids.Count, Is.EqualTo(1));
@@ -78,9 +78,9 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            TestHelpers.InMethod();
            
            UUID missingAssetUuid = UUID.Parse("00000000-0000-0000-0000-000000000666");
-            IDictionary<UUID, AssetType> foundAssetUuids = new Dictionary<UUID, AssetType>();
+            IDictionary<UUID, sbyte> foundAssetUuids = new Dictionary<UUID, sbyte>();
            
-            m_uuidGatherer.GatherAssetUuids(missingAssetUuid, AssetType.Object, foundAssetUuids);
+            m_uuidGatherer.GatherAssetUuids(missingAssetUuid, (sbyte)AssetType.Object, foundAssetUuids);
            // We count the uuid as gathered even if the asset itself is missing.
            Assert.That(foundAssetUuids.Count, Is.EqualTo(1));
@@ -103,8 +103,8 @@ namespace OpenSim.Region.Framework.Scenes.Tests
            AssetBase ncAsset = AssetHelpers.CreateNotecardAsset(ncAssetId, soAssetId.ToString());
            m_assetService.Store(ncAsset);
-            IDictionary<UUID, AssetType> foundAssetUuids = new Dictionary<UUID, AssetType>();
+            IDictionary<UUID, sbyte> foundAssetUuids = new Dictionary<UUID, sbyte>();
-            m_uuidGatherer.GatherAssetUuids(ncAssetId, AssetType.Notecard, foundAssetUuids);
+            m_uuidGatherer.GatherAssetUuids(ncAssetId, (sbyte)AssetType.Notecard, foundAssetUuids);
            // We count the uuid as gathered even if the asset itself is corrupt.
            Assert.That(foundAssetUuids.Count, Is.EqualTo(2));
diff --git a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
index b09ae39..67655d6 100644
--- a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
+++ b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
@@ -34,9 +34,11 @@ using System.Threading;
 using log4net;
 using OpenMetaverse;
 using OpenMetaverse.Assets;
+using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Services.Interfaces;
+using OpenSimAssetType = OpenSim.Framework.SLUtil.OpenSimAssetType;
 namespace OpenSim.Region.Framework.Scenes
 {
@@ -82,29 +84,33 @@ namespace OpenSim.Region.Framework.Scenes
        /// <param name="assetUuid">The uuid of the asset for which to gather referenced assets</param>
        /// <param name="assetType">The type of the asset for the uuid given</param>
        /// <param name="assetUuids">The assets gathered</param>
-        public void GatherAssetUuids(UUID assetUuid, AssetType assetType, IDictionary<UUID, AssetType> assetUuids)
+        public void GatherAssetUuids(UUID assetUuid, sbyte assetType, IDictionary<UUID, sbyte> assetUuids)
        {
            try
            {               
                assetUuids[assetUuid] = assetType;
    
-                if (AssetType.Bodypart == assetType || AssetType.Clothing == assetType)
+                if ((sbyte)AssetType.Bodypart == assetType || (sbyte)AssetType.Clothing == assetType)
                {
                    GetWearableAssetUuids(assetUuid, assetUuids);
                }
-                else if (AssetType.Gesture == assetType)
+                else if ((sbyte)AssetType.Gesture == assetType)
                {
                    GetGestureAssetUuids(assetUuid, assetUuids);
                }
-                else if (AssetType.Notecard == assetType)
+                else if ((sbyte)AssetType.Notecard == assetType)
                {
                    GetTextEmbeddedAssetUuids(assetUuid, assetUuids);
                }
-                else if (AssetType.LSLText == assetType)
+                else if ((sbyte)AssetType.LSLText == assetType)
                {
                    GetTextEmbeddedAssetUuids(assetUuid, assetUuids);
                }
-                else if (AssetType.Object == assetType)
+                else if ((sbyte)OpenSimAssetType.Material == assetType)
+                {
+                    GetMaterialAssetUuids(assetUuid, assetUuids);
+                }
+                else if ((sbyte)AssetType.Object == assetType)
                {
                    GetSceneObjectAssetUuids(assetUuid, assetUuids);
                }
@@ -131,7 +137,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// A dictionary which is populated with the asset UUIDs gathered and the type of that asset.
        /// For assets where the type is not clear (e.g. UUIDs extracted from LSL and notecards), the type is Unknown.
        /// </param>
-        public void GatherAssetUuids(SceneObjectGroup sceneObject, IDictionary<UUID, AssetType> assetUuids)
+        public void GatherAssetUuids(SceneObjectGroup sceneObject, IDictionary<UUID, sbyte> assetUuids)
        {
 //            m_log.DebugFormat(
 //                "[ASSET GATHERER]: Getting assets for object {0}, {1}", sceneObject.Name, sceneObject.UUID);
@@ -151,7 +157,7 @@ namespace OpenSim.Region.Framework.Scenes
                    {
                        // Get the prim's default texture.  This will be used for faces which don't have their own texture
                        if (textureEntry.DefaultTexture != null)
-                            assetUuids[textureEntry.DefaultTexture.TextureID] = AssetType.Texture;
+                            assetUuids[textureEntry.DefaultTexture.TextureID] = (sbyte)AssetType.Texture;
                        if (textureEntry.FaceTextures != null)
                        {
@@ -159,15 +165,37 @@ namespace OpenSim.Region.Framework.Scenes
                            foreach (Primitive.TextureEntryFace texture in textureEntry.FaceTextures)
                            {
                                if (texture != null)
-                                    assetUuids[texture.TextureID] = AssetType.Texture;
+                                    assetUuids[texture.TextureID] = (sbyte)AssetType.Texture;
                            }
                        }
                    }
                    
                    // If the prim is a sculpt then preserve this information too
                    if (part.Shape.SculptTexture != UUID.Zero)
-                        assetUuids[part.Shape.SculptTexture] = AssetType.Texture;
+                        assetUuids[part.Shape.SculptTexture] = (sbyte)AssetType.Texture;
-                    
+                    if (part.Shape.ProjectionTextureUUID != UUID.Zero)
+                        assetUuids[part.Shape.ProjectionTextureUUID] = (sbyte)AssetType.Texture;
+                    if (part.CollisionSound != UUID.Zero)
+                        assetUuids[part.CollisionSound] = (sbyte)AssetType.Sound;
+                    if (part.ParticleSystem.Length > 0)
+                    {
+                        try
+                        {
+                            Primitive.ParticleSystem ps = new Primitive.ParticleSystem(part.ParticleSystem, 0);
+                            if (ps.Texture != UUID.Zero)
+                                assetUuids[ps.Texture] = (sbyte)AssetType.Texture;
+                        }
+                        catch (Exception e)
+                        {
+                            m_log.WarnFormat(
+                                "[UUID GATHERER]: Could not check particle system for part {0} {1} in object {2} {3} since it is corrupt.  Continuing.", 
+                                part.Name, part.UUID, sceneObject.Name, sceneObject.UUID);
+                        }
+                    }
                    TaskInventoryDictionary taskDictionary = (TaskInventoryDictionary)part.TaskInventory.Clone();
                    
                    // Now analyze this prim's inventory items to preserve all the uuids that they reference
@@ -178,8 +206,18 @@ namespace OpenSim.Region.Framework.Scenes
 //                            tii.Name, tii.Type, part.Name, part.UUID);
                        if (!assetUuids.ContainsKey(tii.AssetID))
-                            GatherAssetUuids(tii.AssetID, (AssetType)tii.Type, assetUuids);
+                            GatherAssetUuids(tii.AssetID, (sbyte)tii.Type, assetUuids);
                    }
+                    // FIXME: We need to make gathering modular but we cannot yet, since gatherers are not guaranteed
+                    // to be called with scene objects that are in a scene (e.g. in the case of hg asset mapping and
+                    // inventory transfer.  There needs to be a way for a module to register a method without assuming a 
+                    // Scene.EventManager is present.
+//                    part.ParentGroup.Scene.EventManager.TriggerGatherUuids(part, assetUuids);
+                    // still needed to retrieve textures used as materials for any parts containing legacy materials stored in DynAttrs
+                    GatherMaterialsUuids(part, assetUuids); 
                }
                catch (Exception e)
                {
@@ -190,7 +228,7 @@ namespace OpenSim.Region.Framework.Scenes
                }
            }
        }
-        
 //        /// <summary>
 //        /// The callback made when we request the asset for an object from the asset service.
 //        /// </summary>
@@ -205,6 +243,75 @@ namespace OpenSim.Region.Framework.Scenes
 //        }
        /// <summary>
+        /// Gather all of the texture asset UUIDs used to reference "Materials" such as normal and specular maps
+        /// stored in legacy format in part.DynAttrs
+        /// </summary>
+        /// <param name="part"></param>
+        /// <param name="assetUuids"></param>
+        //public void GatherMaterialsUuids(SceneObjectPart part, IDictionary<UUID, AssetType> assetUuids)
+        public void GatherMaterialsUuids(SceneObjectPart part, IDictionary<UUID, sbyte> assetUuids)
+        {
+            // scan thru the dynAttrs map of this part for any textures used as materials
+            OSD osdMaterials = null;
+            lock (part.DynAttrs)
+            {
+                if (part.DynAttrs.ContainsStore("OpenSim", "Materials"))
+                {
+                    OSDMap materialsStore = part.DynAttrs.GetStore("OpenSim", "Materials");
+                    if (materialsStore == null)
+                        return;
+                    materialsStore.TryGetValue("Materials", out osdMaterials);
+                }
+                if (osdMaterials != null)
+                {
+                    //m_log.Info("[UUID Gatherer]: found Materials: " + OSDParser.SerializeJsonString(osd));
+                    if (osdMaterials is OSDArray)
+                    {
+                        OSDArray matsArr = osdMaterials as OSDArray;
+                        foreach (OSDMap matMap in matsArr)
+                        {
+                            try
+                            {
+                                if (matMap.ContainsKey("Material"))
+                                {
+                                    OSDMap mat = matMap["Material"] as OSDMap;
+                                    if (mat.ContainsKey("NormMap"))
+                                    {
+                                        UUID normalMapId = mat["NormMap"].AsUUID();
+                                        if (normalMapId != UUID.Zero)
+                                        {
+                                            assetUuids[normalMapId] = (sbyte)AssetType.Texture;
+                                            //m_log.Info("[UUID Gatherer]: found normal map ID: " + normalMapId.ToString());
+                                        }
+                                    }
+                                    if (mat.ContainsKey("SpecMap"))
+                                    {
+                                        UUID specularMapId = mat["SpecMap"].AsUUID();
+                                        if (specularMapId != UUID.Zero)
+                                        {
+                                            assetUuids[specularMapId] = (sbyte)AssetType.Texture;
+                                            //m_log.Info("[UUID Gatherer]: found specular map ID: " + specularMapId.ToString());
+                                        }
+                                    }
+                                }
+                            }
+                            catch (Exception e)
+                            {
+                                m_log.Warn("[UUID Gatherer]: exception getting materials: " + e.Message);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+       
+        /// <summary>
        /// Get an asset synchronously, potentially using an asynchronous callback.  If the
        /// asynchronous callback is used, we will wait for it to complete.
        /// </summary>
@@ -242,7 +349,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        /// <param name="scriptUuid"></param>
        /// <param name="assetUuids">Dictionary in which to record the references</param>
-        private void GetTextEmbeddedAssetUuids(UUID embeddingAssetId, IDictionary<UUID, AssetType> assetUuids)
+        private void GetTextEmbeddedAssetUuids(UUID embeddingAssetId, IDictionary<UUID, sbyte> assetUuids)
        {
 //            m_log.DebugFormat("[ASSET GATHERER]: Getting assets for uuid references in asset {0}", embeddingAssetId);
@@ -262,7 +369,7 @@ namespace OpenSim.Region.Framework.Scenes
                    // Embedded asset references (if not false positives) could be for many types of asset, so we will
                    // label these as unknown.
-                    assetUuids[uuid] = AssetType.Unknown;
+                    assetUuids[uuid] = (sbyte)AssetType.Unknown;
                }
            }
        }
@@ -272,7 +379,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        /// <param name="wearableAssetUuid"></param>
        /// <param name="assetUuids">Dictionary in which to record the references</param>
-        private void GetWearableAssetUuids(UUID wearableAssetUuid, IDictionary<UUID, AssetType> assetUuids)
+        private void GetWearableAssetUuids(UUID wearableAssetUuid, IDictionary<UUID, sbyte> assetUuids)
        {
            AssetBase assetBase = GetAsset(wearableAssetUuid);
@@ -287,7 +394,7 @@ namespace OpenSim.Region.Framework.Scenes
    
                foreach (UUID uuid in wearableAsset.Textures.Values)
                {
-                    assetUuids[uuid] = AssetType.Texture;
+                    assetUuids[uuid] = (sbyte)AssetType.Texture;
                }
            }
        }
@@ -299,7 +406,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        /// <param name="sceneObject"></param>
        /// <param name="assetUuids"></param>
-        private void GetSceneObjectAssetUuids(UUID sceneObjectUuid, IDictionary<UUID, AssetType> assetUuids)
+        private void GetSceneObjectAssetUuids(UUID sceneObjectUuid, IDictionary<UUID, sbyte> assetUuids)
        {
            AssetBase objectAsset = GetAsset(sceneObjectUuid);
@@ -328,7 +435,7 @@ namespace OpenSim.Region.Framework.Scenes
        /// </summary>
        /// <param name="gestureUuid"></param>
        /// <param name="assetUuids"></param>
-        private void GetGestureAssetUuids(UUID gestureUuid, IDictionary<UUID, AssetType> assetUuids)
+        private void GetGestureAssetUuids(UUID gestureUuid, IDictionary<UUID, sbyte> assetUuids)
        {
            AssetBase assetBase = GetAsset(gestureUuid);
            if (null == assetBase)
@@ -362,9 +469,29 @@ namespace OpenSim.Region.Framework.Scenes
                // If it can be parsed as a UUID, it is an asset ID
                UUID uuid;
                if (UUID.TryParse(id, out uuid))
-                    assetUuids[uuid] = AssetType.Animation;
+                    assetUuids[uuid] = (sbyte)AssetType.Animation;
            }
        }
+        /// <summary>
+        /// Get the asset uuid's referenced in a material.
+        /// </summary>
+        private void GetMaterialAssetUuids(UUID materialUuid, IDictionary<UUID, sbyte> assetUuids)
+        {
+            AssetBase assetBase = GetAsset(materialUuid);
+            if (null == assetBase)
+                return;
+            OSDMap mat = (OSDMap)OSDParser.DeserializeLLSDXml(assetBase.Data);
+            UUID normMap = mat["NormMap"].AsUUID();
+            if (normMap != UUID.Zero)
+                assetUuids[normMap] = (sbyte)AssetType.Texture;
+            UUID specMap = mat["SpecMap"].AsUUID();
+            if (specMap != UUID.Zero)
+                assetUuids[specMap] = (sbyte)AssetType.Texture;
+        }
    }
    public class HGUuidGatherer : UuidGatherer