Initial update to OpenSim 0.8.2.1 source code.

2 files changed, 908 insertions, 314 deletions

diff --git a/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs b/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
index 58ed554..2f67c4e 100644
--- a/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
@@ -29,6 +29,7 @@ using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.IO;
+using System.Threading;
 using System.Xml;
 using log4net;
 using Mono.Addins;
@@ -48,6 +49,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
     {
         #region INonSharedRegionModule
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public int DebugLevel { get; set; }
+
+        /// <summary>
+        /// Period to sleep per 100 prims in order to avoid CPU spikes when an avatar with many attachments logs in/changes
+        /// outfit or many avatars with a medium levels of attachments login/change outfit simultaneously.
+        /// </summary>
+        /// <remarks>
+        /// A value of 0 will apply no pause.  The pause is specified in milliseconds.
+        /// </remarks>
+        public int ThrottlePer100PrimsRezzed { get; set; }
         
         private Scene m_scene;
         private IInventoryAccessModule m_invAccessModule;
@@ -64,21 +76,127 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
         {
             IConfig config = source.Configs["Attachments"];
             if (config != null)
+            {
                 Enabled = config.GetBoolean("Enabled", true);
+
+                ThrottlePer100PrimsRezzed = config.GetInt("ThrottlePer100PrimsRezzed", 0);
+            }
             else
+            {
                 Enabled = true;
+            }
         }
         
         public void AddRegion(Scene scene)
         {
             m_scene = scene;
-            m_scene.RegisterModuleInterface<IAttachmentsModule>(this);
-
             if (Enabled)
+            {
+                // Only register module with scene if it is enabled. All callers check for a null attachments module.
+                // Ideally, there should be a null attachments module for when this core attachments module has been 
+                // disabled. Registering only when enabled allows for other attachments module implementations.
+                m_scene.RegisterModuleInterface<IAttachmentsModule>(this);
                 m_scene.EventManager.OnNewClient += SubscribeToClientEvents;
+                m_scene.EventManager.OnStartScript += (localID, itemID) => HandleScriptStateChange(localID, true);
+                m_scene.EventManager.OnStopScript += (localID, itemID) => HandleScriptStateChange(localID, false);
+
+                MainConsole.Instance.Commands.AddCommand(
+                    "Debug",
+                    false,
+                    "debug attachments log",
+                    "debug attachments log [0|1]",
+                    "Turn on attachments debug logging",
+                    "  <= 0 - turns off debug logging\n"
+                        + "  >= 1 - turns on attachment message debug logging",
+                    HandleDebugAttachmentsLog);
+
+                MainConsole.Instance.Commands.AddCommand(
+                    "Debug",
+                    false,
+                    "debug attachments throttle",
+                    "debug attachments throttle <ms>",
+                    "Turn on attachments throttling.",
+                    "This requires a millisecond value.  " +
+                    "  == 0 - disable throttling.\n"
+                        + "  > 0 - sleeps for this number of milliseconds per 100 prims rezzed.",
+                    HandleDebugAttachmentsThrottle);
+
+                MainConsole.Instance.Commands.AddCommand(
+                    "Debug",
+                    false,
+                    "debug attachments status",
+                    "debug attachments status",
+                    "Show current attachments debug status",
+                    HandleDebugAttachmentsStatus);
+            }
 
             // TODO: Should probably be subscribing to CloseClient too, but this doesn't yet give us IClientAPI
         }
+
+        private void HandleDebugAttachmentsLog(string module, string[] args)
+        {
+            int debugLevel;
+
+            if (!(args.Length == 4 && int.TryParse(args[3], out debugLevel)))
+            {
+                MainConsole.Instance.OutputFormat("Usage: debug attachments log [0|1]");
+            }
+            else
+            {
+                DebugLevel = debugLevel;
+                MainConsole.Instance.OutputFormat(
+                    "Set attachments debug level to {0} in {1}", DebugLevel, m_scene.Name);
+            }
+        }
+
+        private void HandleDebugAttachmentsThrottle(string module, string[] args)
+        {
+            int ms;
+
+            if (args.Length == 4 && int.TryParse(args[3], out ms))
+            {
+                ThrottlePer100PrimsRezzed = ms;
+                MainConsole.Instance.OutputFormat(
+                    "Attachments rez throttle per 100 prims is now {0} in {1}", ThrottlePer100PrimsRezzed, m_scene.Name);
+
+                return;
+            }
+
+            MainConsole.Instance.OutputFormat("Usage: debug attachments throttle <ms>");
+        }
+
+        private void HandleDebugAttachmentsStatus(string module, string[] args)
+        {
+            MainConsole.Instance.OutputFormat("Settings for {0}", m_scene.Name);
+            MainConsole.Instance.OutputFormat("Debug logging level: {0}", DebugLevel);
+            MainConsole.Instance.OutputFormat("Throttle per 100 prims: {0}ms", ThrottlePer100PrimsRezzed);
+        }
+
+        /// <summary>
+        /// Listen for client triggered running state changes so that we can persist the script's object if necessary.
+        /// </summary>
+        /// <param name='localID'></param>
+        /// <param name='itemID'></param>
+        private void HandleScriptStateChange(uint localID, bool started)
+        {
+            SceneObjectGroup sog = m_scene.GetGroupByPrim(localID);
+            if (sog != null && sog.IsAttachment) 
+            {
+                if (!started)
+                {
+                    // FIXME: This is a convoluted way for working out whether the script state has changed to stop
+                    // because it has been manually stopped or because the stop was called in UpdateDetachedObject() below
+                    // This needs to be handled in a less tangled way.
+                    ScenePresence sp = m_scene.GetScenePresence(sog.AttachedAvatar);
+                    if (sp.ControllingClient.IsActive)
+                        sog.HasGroupChanged = true;
+                }
+                else
+                {
+                    sog.HasGroupChanged = true;
+                }
+            }
+        }
         
         public void RemoveRegion(Scene scene) 
         {
@@ -127,8 +245,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                         string state = sog.GetStateSnapshot();
                         ad.AttachmentObjectStates.Add(state);
                         sp.InTransitScriptStates.Add(state);
-                        // Let's remove the scripts of the original object here
-                        sog.RemoveScriptInstances(true);
+
+                        // Scripts of the originals will be removed when the Agent is successfully removed.
+                        // sog.RemoveScriptInstances(true);
                     }
                 }
             }
@@ -136,6 +255,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
         public void CopyAttachments(AgentData ad, IScenePresence sp)
         {
+//            m_log.DebugFormat("[ATTACHMENTS MODULE]: Copying attachment data into {0} in {1}", sp.Name, m_scene.Name);
+
             if (ad.AttachmentObjects != null && ad.AttachmentObjects.Count > 0)
             {
                 lock (sp.AttachmentsSyncLock)
@@ -146,16 +267,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                 {
                     ((SceneObjectGroup)so).LocalId = 0;
                     ((SceneObjectGroup)so).RootPart.ClearUpdateSchedule();
+
+//                    m_log.DebugFormat(
+//                        "[ATTACHMENTS MODULE]: Copying script state with {0} bytes for object {1} for {2} in {3}", 
+//                        ad.AttachmentObjectStates[i].Length, so.Name, sp.Name, m_scene.Name);
+
                     so.SetState(ad.AttachmentObjectStates[i++], m_scene);
                     m_scene.IncomingCreateObject(Vector3.Zero, so);
                 }
             }
         }
 
-        /// <summary>
-        /// RezAttachments. This should only be called upon login on the first region.
-        /// Attachment rezzings on crossings and TPs are done in a different way.
-        /// </summary>
         public void RezAttachments(IScenePresence sp)
         {
             if (!Enabled)
@@ -164,15 +286,35 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (null == sp.Appearance)
             {
                 m_log.WarnFormat("[ATTACHMENTS MODULE]: Appearance has not been initialized for agent {0}", sp.UUID);
+
                 return;
             }
 
-//            m_log.DebugFormat("[ATTACHMENTS MODULE]: Rezzing any attachments for {0}", sp.Name);
+            if (sp.GetAttachments().Count > 0)
+            {
+                if (DebugLevel > 0)
+                    m_log.DebugFormat(
+                        "[ATTACHMENTS MODULE]: Not doing simulator-side attachment rez for {0} in {1} as their viewer has already rezzed attachments", 
+                        m_scene.Name, sp.Name);
+
+                  return;
+            }
+
+            if (DebugLevel > 0)
+                m_log.DebugFormat("[ATTACHMENTS MODULE]: Rezzing any attachments for {0} from simulator-side", sp.Name);
 
             List<AvatarAttachment> attachments = sp.Appearance.GetAttachments();
+
+            // Let's get all items at once, so they get cached
+            UUID[] items = new UUID[attachments.Count];
+            int i = 0;
+            foreach (AvatarAttachment attach in attachments)
+                items[i++] = attach.ItemID;
+            m_scene.InventoryService.GetMultipleItems(sp.UUID, items);
+
             foreach (AvatarAttachment attach in attachments)
             {
-                uint p = (uint)attach.AttachPoint;
+                uint attachmentPt = (uint)attach.AttachPoint;
 
 //                m_log.DebugFormat(
 //                    "[ATTACHMENTS MODULE]: Doing initial rez of attachment with itemID {0}, assetID {1}, point {2} for {3} in {4}",
@@ -190,16 +332,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                 {
                     // If we're an NPC then skip all the item checks and manipulations since we don't have an
                     // inventory right now.
-                    if (sp.PresenceType == PresenceType.Npc)
-                        RezSingleAttachmentFromInventoryInternal(sp, UUID.Zero, attach.AssetID, p);
-                    else
-                        RezSingleAttachmentFromInventory(sp, attach.ItemID, p);
+                    RezSingleAttachmentFromInventoryInternal(
+                        sp, sp.PresenceType == PresenceType.Npc ? UUID.Zero : attach.ItemID, attach.AssetID, attachmentPt, true);
                 }
                 catch (Exception e)
                 {
-                    UUID agentId = (sp.ControllingClient == null) ? (UUID)null : sp.ControllingClient.AgentId;
+                    UUID agentId = (sp.ControllingClient == null) ? default(UUID) : sp.ControllingClient.AgentId;
                     m_log.ErrorFormat("[ATTACHMENTS MODULE]: Unable to rez attachment with itemID {0}, assetID {1}, point {2} for {3}: {4}\n{5}",
-                        attach.ItemID, attach.AssetID, p, agentId, e.Message, e.StackTrace);
+                        attach.ItemID, attach.AssetID, attachmentPt, agentId, e.Message, e.StackTrace);
                 }
             }
         }
@@ -209,14 +349,36 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (!Enabled)
                 return;
 
-//            m_log.DebugFormat("[ATTACHMENTS MODULE]: Saving changed attachments for {0}", sp.Name);
+            List<SceneObjectGroup> attachments = sp.GetAttachments();
+
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Saving for {0} attachments for {1} in {2}",
+                    attachments.Count, sp.Name, m_scene.Name);
+
+            if (attachments.Count <= 0)
+                return;
+
+            Dictionary<SceneObjectGroup, string> scriptStates = new Dictionary<SceneObjectGroup, string>();
+
+            foreach (SceneObjectGroup so in attachments)
+            {
+                // Scripts MUST be snapshotted before the object is
+                // removed from the scene because doing otherwise will
+                // clobber the run flag
+                // This must be done outside the sp.AttachmentSyncLock so that there is no risk of a deadlock from
+                // scripts performing attachment operations at the same time.  Getting object states stops the scripts.
+                scriptStates[so] = PrepareScriptInstanceForSave(so, false);
+
+//                m_log.DebugFormat(
+//                    "[ATTACHMENTS MODULE]: For object {0} for {1} in {2} got saved state {3}", 
+//                    so.Name, sp.Name, m_scene.Name, scriptStates[so]);
+            }
 
             lock (sp.AttachmentsSyncLock)
             {
-                foreach (SceneObjectGroup so in sp.GetAttachments())
-                {
-                    UpdateDetachedObject(sp, so);
-                }
+                foreach (SceneObjectGroup so in attachments)
+                    UpdateDetachedObject(sp, so, scriptStates[so]);
     
                 sp.ClearAttachments();
             }
@@ -227,9 +389,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (!Enabled)
                 return;
 
-//            m_log.DebugFormat(
-//                "[ATTACHMENTS MODULE]: Deleting attachments from scene {0} for {1}, silent = {2}",
-//                m_scene.RegionInfo.RegionName, sp.Name, silent);            
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Deleting attachments from scene {0} for {1}, silent = {2}",
+                    m_scene.RegionInfo.RegionName, sp.Name, silent);            
 
             foreach (SceneObjectGroup sop in sp.GetAttachments())
             {
@@ -238,114 +401,149 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
             sp.ClearAttachments();
         }
-
-        public bool AttachObject(IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool silent, bool temp)
+        
+        public bool AttachObject(
+            IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool silent, bool addToInventory, bool append)
         {
             if (!Enabled)
                 return false;
 
-            if (AttachObjectInternal(sp, group, attachmentPt, silent, temp))
-            {
-                m_scene.EventManager.TriggerOnAttach(group.LocalId, group.FromItemID, sp.UUID);
-                return true;
-            }
+            group.DetachFromBackup();
 
-            return false;
+            bool success = AttachObjectInternal(sp, group, attachmentPt, silent, addToInventory, false, append);
+
+            if (!success)
+                group.AttachToBackup();
+
+            return success;
         }
-        
-        private bool AttachObjectInternal(IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool silent, bool temp)
+
+        /// <summary>
+        /// Internal method which actually does all the work for attaching an object.
+        /// </summary>
+        /// <returns>The object attached.</returns>
+        /// <param name='sp'></param>
+        /// <param name='group'>The object to attach.</param>
+        /// <param name='attachmentPt'></param>
+        /// <param name='silent'></param>
+        /// <param name='addToInventory'>If true then add object to user inventory.</param>
+        /// <param name='resumeScripts'>If true then scripts are resumed on the attached object.</param>
+        /// <param name='append'>Append to attachment point rather than replace.</param>
+        private bool AttachObjectInternal(
+            IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool silent, bool addToInventory, bool resumeScripts, bool append)
         {
-            lock (sp.AttachmentsSyncLock)
+            if (group.GetSittingAvatarsCount() != 0)
             {
-//                m_log.DebugFormat(
-//                    "[ATTACHMENTS MODULE]: Attaching object {0} {1} to {2} point {3} from ground (silent = {4})",
-//                    group.Name, group.LocalId, sp.Name, attachmentPt, silent);
+                if (DebugLevel > 0)
+                    m_log.WarnFormat(
+                        "[ATTACHMENTS MODULE]: Ignoring request to attach {0} {1} to {2} on {3} since {4} avatars are still sitting on it",
+                        group.Name, group.LocalId, sp.Name, attachmentPt, group.GetSittingAvatarsCount());
 
-                if (group.GetSittingAvatarsCount() != 0)
-                {
-//                    m_log.WarnFormat(
-//                        "[ATTACHMENTS MODULE]: Ignoring request to attach {0} {1} to {2} on {3} since {4} avatars are still sitting on it",
-//                        group.Name, group.LocalId, sp.Name, attachmentPt, group.GetSittingAvatarsCount());
-    
-                    return false;
-                }
-    
-                if (sp.GetAttachments(attachmentPt).Contains(group))
-                {
-    //                m_log.WarnFormat(
-    //                    "[ATTACHMENTS MODULE]: Ignoring request to attach {0} {1} to {2} on {3} since it's already attached",
-    //                    group.Name, group.LocalId, sp.Name, AttachmentPt);
-    
-                    return false;
-                }
-    
-                Vector3 attachPos = group.AbsolutePosition;
-    
-                // TODO: this short circuits multiple attachments functionality  in  LL viewer 2.1+ and should
-                // be removed when that functionality is implemented in opensim
-                attachmentPt &= 0x7f;
-                
-                // If the attachment point isn't the same as the one previously used
-                // set it's offset position = 0 so that it appears on the attachment point
-                // and not in a weird location somewhere unknown.
-                if (attachmentPt != 0 && attachmentPt != group.AttachmentPoint)
-                {
-                    attachPos = Vector3.Zero;
-                }
-    
-                // AttachmentPt 0 means the client chose to 'wear' the attachment.
-                if (attachmentPt == 0)
+                return false;
+            }
+
+            Vector3 attachPos = group.AbsolutePosition;
+            // If the attachment point isn't the same as the one previously used
+            // set it's offset position = 0 so that it appears on the attachment point
+            // and not in a weird location somewhere unknown.
+            if (attachmentPt != (uint)AttachmentPoint.Default && attachmentPt != group.AttachmentPoint)
+            {
+                attachPos = Vector3.Zero;
+            }
+
+            // if the attachment point is the same as previous, make sure we get the saved
+            // position info.
+            if (attachmentPt != 0 && attachmentPt == group.RootPart.Shape.LastAttachPoint)
+            {
+                attachPos = group.RootPart.AttachedPos;
+            }
+
+            // AttachmentPt 0 means the client chose to 'wear' the attachment.
+            if (attachmentPt == (uint)AttachmentPoint.Default)
+            {
+                // Check object for stored attachment point
+                attachmentPt = group.AttachmentPoint;
+            }
+
+            // if we didn't find an attach point, look for where it was last attached
+            if (attachmentPt == 0)
+            {
+                attachmentPt = (uint)group.RootPart.Shape.LastAttachPoint;
+                attachPos = group.RootPart.AttachedPos;
+                group.HasGroupChanged = true;
+            }
+
+            // if we still didn't find a suitable attachment point.......
+            if (attachmentPt == 0)
+            {
+                // Stick it on left hand with Zero Offset from the attachment point.
+                attachmentPt = (uint)AttachmentPoint.LeftHand;
+                attachPos = Vector3.Zero;
+            }
+
+            group.AttachmentPoint = attachmentPt;
+            group.AbsolutePosition = attachPos;
+
+            List<SceneObjectGroup> attachments = sp.GetAttachments(attachmentPt);
+
+            if (attachments.Contains(group))
+            {
+                if (DebugLevel > 0)
+                    m_log.WarnFormat(
+                        "[ATTACHMENTS MODULE]: Ignoring request to attach {0} {1} to {2} on {3} since it's already attached",
+                        group.Name, group.LocalId, sp.Name, attachmentPt);
+
+                return false;
+            }
+
+            // If we already have 5, remove the oldest until only 4 are left. Skip over temp ones
+            while (attachments.Count >= 5)
+            {
+                if (attachments[0].FromItemID != UUID.Zero)
+                    DetachSingleAttachmentToInv(sp, attachments[0]);
+                attachments.RemoveAt(0);
+            }
+
+            // If we're not appending, remove the rest as well
+            if (attachments.Count != 0 && !append)
+            {
+                foreach (SceneObjectGroup g in attachments)
                 {
-                    // Check object for stored attachment point
-                    attachmentPt = group.AttachmentPoint;
+                    if (g.FromItemID != UUID.Zero)
+                        DetachSingleAttachmentToInv(sp, g);
                 }
+            }
+
+            lock (sp.AttachmentsSyncLock)
+            {
+                if (addToInventory && sp.PresenceType != PresenceType.Npc)
+                    UpdateUserInventoryWithAttachment(sp, group, attachmentPt, append);
     
-                // if we still didn't find a suitable attachment point.......
-                if (attachmentPt == 0)
+                AttachToAgent(sp, group, attachmentPt, attachPos, silent);
+
+                if (resumeScripts)
                 {
-                    // Stick it on left hand with Zero Offset from the attachment point.
-                    attachmentPt = (uint)AttachmentPoint.LeftHand;
-                    attachPos = Vector3.Zero;
+                    // Fire after attach, so we don't get messy perms dialogs
+                    // 4 == AttachedRez
+                    group.CreateScriptInstances(0, true, m_scene.DefaultScriptEngine, 4);
+                    group.ResumeScripts();
                 }
-    
-                group.AttachmentPoint = attachmentPt;
-                group.AbsolutePosition = attachPos;
 
-                if (sp.PresenceType != PresenceType.Npc)
-                    UpdateUserInventoryWithAttachment(sp, group, attachmentPt, temp);
-    
-                AttachToAgent(sp, group, attachmentPt, attachPos, silent);
+                // Do this last so that event listeners have access to all the effects of the attachment
+                m_scene.EventManager.TriggerOnAttach(group.LocalId, group.FromItemID, sp.UUID);
             }
 
             return true;
         }
 
-        private void UpdateUserInventoryWithAttachment(IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool temp)
+        private void UpdateUserInventoryWithAttachment(IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool append)
         {
-            // Remove any previous attachments
-            List<SceneObjectGroup> attachments = sp.GetAttachments(attachmentPt);
-
-            // At the moment we can only deal with a single attachment
-            if (attachments.Count != 0)
-            {
-                if (attachments[0].FromItemID != UUID.Zero)
-                    DetachSingleAttachmentToInvInternal(sp, attachments[0]);
-            // Error logging commented because UUID.Zero now means temp attachment
-//                else
-//                    m_log.WarnFormat(
-//                        "[ATTACHMENTS MODULE]: When detaching existing attachment {0} {1} at point {2} to make way for {3} {4} for {5}, couldn't find the associated item ID to adjust inventory attachment record!",
-//                        attachments[0].Name, attachments[0].LocalId, attachmentPt, group.Name, group.LocalId, sp.Name);
-            }
-
             // Add the new attachment to inventory if we don't already have it.
-            if (!temp)
-            {
-                UUID newAttachmentItemID = group.FromItemID;
-                if (newAttachmentItemID == UUID.Zero)
-                    newAttachmentItemID = AddSceneObjectAsNewAttachmentInInv(sp, group).ID;
+            UUID newAttachmentItemID = group.FromItemID;
+            if (newAttachmentItemID == UUID.Zero)
+                newAttachmentItemID = AddSceneObjectAsNewAttachmentInInv(sp, group).ID;
 
-                ShowAttachInUserInventory(sp, attachmentPt, newAttachmentItemID, group);
-            }
+            ShowAttachInUserInventory(sp, attachmentPt, newAttachmentItemID, group, append);
         }
 
         public SceneObjectGroup RezSingleAttachmentFromInventory(IScenePresence sp, UUID itemID, uint AttachmentPt)
@@ -353,41 +551,40 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (!Enabled)
                 return null;
 
-//            m_log.DebugFormat(
-//                "[ATTACHMENTS MODULE]: RezSingleAttachmentFromInventory to point {0} from item {1} for {2}",
-//                (AttachmentPoint)AttachmentPt, itemID, sp.Name);
-
-            // TODO: this short circuits multiple attachments functionality  in  LL viewer 2.1+ and should
-            // be removed when that functionality is implemented in opensim
-            AttachmentPt &= 0x7f;
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: RezSingleAttachmentFromInventory to point {0} from item {1} for {2} in {3}",
+                    (AttachmentPoint)AttachmentPt, itemID, sp.Name, m_scene.Name);
 
-            // Viewer 2/3 sometimes asks to re-wear items that are already worn (and show up in it's inventory as such).
-            // This often happens during login - not sure the exact reason.
-            // For now, we will ignore the request.  Unfortunately, this means that we need to dig through all the
-            // ScenePresence attachments.  We can't use the data in AvatarAppearance because that's present at login
-            // before anything has actually been attached.
+            // We check the attachments in the avatar appearance here rather than the objects attached to the
+            // ScenePresence itself so that we can ignore calls by viewer 2/3 to attach objects on startup.  We are 
+            // already doing this in ScenePresence.MakeRootAgent().  Simulator-side attaching needs to be done 
+            // because pre-outfit folder viewers (most version 1 viewers) require it.
             bool alreadyOn = false;
-            List<SceneObjectGroup> existingAttachments = sp.GetAttachments();
-            foreach (SceneObjectGroup so in existingAttachments)
+            List<AvatarAttachment> existingAttachments = sp.Appearance.GetAttachments();
+            foreach (AvatarAttachment existingAttachment in existingAttachments)
             {
-                if (so.FromItemID == itemID)
+                if (existingAttachment.ItemID == itemID)
                 {
                     alreadyOn = true;
                     break;
                 }
             }
 
-//            if (sp.Appearance.GetAttachmentForItem(itemID) != null)
             if (alreadyOn)
             {
-//                m_log.WarnFormat(
-//                    "[ATTACHMENTS MODULE]: Ignoring request by {0} to wear item {1} at {2} since it is already worn",
-//                    sp.Name, itemID, AttachmentPt);
+                if (DebugLevel > 0)
+                    m_log.DebugFormat(
+                        "[ATTACHMENTS MODULE]: Ignoring request by {0} to wear item {1} at {2} since it is already worn",
+                        sp.Name, itemID, AttachmentPt);
 
                 return null;
             }
 
-            return RezSingleAttachmentFromInventoryInternal(sp, itemID, UUID.Zero, AttachmentPt);
+            bool append = (AttachmentPt & 0x80) != 0;
+            AttachmentPt &= 0x7f;
+
+            return RezSingleAttachmentFromInventoryInternal(sp, itemID, UUID.Zero, AttachmentPt, append);
         }
 
         public void RezMultipleAttachmentsFromInventory(IScenePresence sp, List<KeyValuePair<UUID, uint>> rezlist)
@@ -395,13 +592,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (!Enabled)
                 return;
 
-            //                m_log.DebugFormat("[ATTACHMENTS MODULE]: Rezzing multiple attachments from inventory for {0}", sp.Name);
-            lock (sp.AttachmentsSyncLock)
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Rezzing {0} attachments from inventory for {1} in {2}", 
+                    rezlist.Count, sp.Name, m_scene.Name);
+
+            foreach (KeyValuePair<UUID, uint> rez in rezlist)
             {
-                foreach (KeyValuePair<UUID, uint> rez in rezlist)
-                {
-                    RezSingleAttachmentFromInventory(sp, rez.Key, rez.Value);
-                }
+                RezSingleAttachmentFromInventory(sp, rez.Key, rez.Value);
             }
         }
 
@@ -415,9 +613,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (!Enabled)
                 return;
 
-//            m_log.DebugFormat(
-//                "[ATTACHMENTS MODULE]: DetachSingleAttachmentToGround() for {0}, object {1}",
-//                sp.UUID, soLocalId);
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: DetachSingleAttachmentToGround() for {0}, object {1}",
+                    sp.UUID, soLocalId);
 
             SceneObjectGroup so = m_scene.GetGroupByPrim(soLocalId);
 
@@ -433,9 +632,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (inventoryID == UUID.Zero)
                 return;
 
-//            m_log.DebugFormat(
-//                "[ATTACHMENTS MODULE]: In DetachSingleAttachmentToGround(), object is {0} {1}, associated item is {2}",
-//                so.Name, so.LocalId, inventoryID);
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: In DetachSingleAttachmentToGround(), object is {0} {1}, associated item is {2}",
+                    so.Name, so.LocalId, inventoryID);
 
             lock (sp.AttachmentsSyncLock)
             {
@@ -463,6 +663,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                 so.ClearPartAttachmentData();
                 rootPart.ApplyPhysics(rootPart.GetEffectiveObjectFlags(), rootPart.VolumeDetectActive);
                 so.HasGroupChanged = true;
+                so.RootPart.Shape.LastAttachPoint = (byte)so.AttachmentPoint;
                 rootPart.Rezzed = DateTime.Now;
                 rootPart.RemFlag(PrimFlags.TemporaryOnRez);
                 so.AttachToBackup();
@@ -481,25 +682,38 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
         public void DetachSingleAttachmentToInv(IScenePresence sp, SceneObjectGroup so)
         {
+            if (so.AttachedAvatar != sp.UUID)
+            {
+                m_log.WarnFormat(
+                    "[ATTACHMENTS MODULE]: Tried to detach object {0} from {1} {2} but attached avatar id was {3} in {4}",
+                    so.Name, sp.Name, sp.UUID, so.AttachedAvatar, m_scene.RegionInfo.RegionName);
+
+                return;
+            }
+
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Detaching object {0} {1} (FromItemID {2}) for {3} in {4}", 
+                    so.Name, so.LocalId, so.FromItemID, sp.Name, m_scene.Name);
+
+            // Scripts MUST be snapshotted before the object is
+            // removed from the scene because doing otherwise will
+            // clobber the run flag
+            // This must be done outside the sp.AttachmentSyncLock so that there is no risk of a deadlock from
+            // scripts performing attachment operations at the same time.  Getting object states stops the scripts.
+            string scriptedState = PrepareScriptInstanceForSave(so, true);
+
             lock (sp.AttachmentsSyncLock)
             {
                 // Save avatar attachment information
 //                m_log.Debug("[ATTACHMENTS MODULE]: Detaching from UserID: " + sp.UUID + ", ItemID: " + itemID);
 
-                if (so.AttachedAvatar != sp.UUID)
-                {
-                    m_log.WarnFormat(
-                        "[ATTACHMENTS MODULE]: Tried to detach object {0} from {1} {2} but attached avatar id was {3} in {4}",
-                        so.Name, sp.Name, sp.UUID, so.AttachedAvatar, m_scene.RegionInfo.RegionName);
-
-                    return;
-                }
-
                 bool changed = sp.Appearance.DetachAttachment(so.FromItemID);
                 if (changed && m_scene.AvatarFactory != null)
                     m_scene.AvatarFactory.QueueAppearanceSave(sp.UUID);
 
-                DetachSingleAttachmentToInvInternal(sp, so);
+                sp.RemoveAttachment(so);
+                UpdateDetachedObject(sp, so, scriptedState);
             }
         }
         
@@ -588,15 +802,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                         (sbyte)AssetType.Object,
                         Utils.StringToBytes(sceneObjectXml),
                         sp.UUID);
-                    m_scene.AssetService.Store(asset);
 
-                    item.AssetID = asset.FullID;
-                    item.Description = asset.Description;
-                    item.Name = asset.Name;
-                    item.AssetType = asset.Type;
-                    item.InvType = (int)InventoryType.Object;
-
-                    m_scene.InventoryService.UpdateItem(item);
+                    if (m_invAccessModule != null)
+                        m_invAccessModule.UpdateInventoryItemAsset(sp.UUID, item, asset);
 
                     // If the name of the object has been changed whilst attached then we want to update the inventory
                     // item in the viewer.
@@ -606,12 +814,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
                 grp.HasGroupChanged = false; // Prevent it being saved over and over
             }
-//            else
-//            {
-//                m_log.DebugFormat(
-//                    "[ATTACHMENTS MODULE]: Don't need to update asset for unchanged attachment {0}, attachpoint {1}",
-//                    grp.UUID, grp.AttachmentPoint);
-//            }
+            else if (DebugLevel > 0)
+            {
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Don't need to update asset for unchanged attachment {0}, attachpoint {1}",
+                    grp.UUID, grp.AttachmentPoint);
+            }
         }
 
         /// <summary>
@@ -629,11 +837,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
         private void AttachToAgent(
             IScenePresence sp, SceneObjectGroup so, uint attachmentpoint, Vector3 attachOffset, bool silent)
         {
-//            m_log.DebugFormat(
-//                "[ATTACHMENTS MODULE]: Adding attachment {0} to avatar {1} in pt {2} pos {3} {4}",
-//                so.Name, sp.Name, attachmentpoint, attachOffset, so.RootPart.AttachedPos);
-
-            so.DetachFromBackup();
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Adding attachment {0} to avatar {1} at pt {2} pos {3} {4} in {5}",
+                    so.Name, sp.Name, attachmentpoint, attachOffset, so.RootPart.AttachedPos, m_scene.Name);
 
             // Remove from database and parcel prim count
             m_scene.DeleteFromStorage(so.UUID);
@@ -656,16 +863,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             {
                 if (so.HasPrivateAttachmentPoint)
                 {
-//                    m_log.DebugFormat(
-//                        "[ATTACHMENTS MODULE]: Killing private HUD {0} for avatars other than {1} at attachment point {2}",
-//                        so.Name, sp.Name, so.AttachmentPoint);
+                    if (DebugLevel > 0)
+                        m_log.DebugFormat(
+                            "[ATTACHMENTS MODULE]: Killing private HUD {0} for avatars other than {1} at attachment point {2}",
+                            so.Name, sp.Name, so.AttachmentPoint);
 
                     // As this scene object can now only be seen by the attaching avatar, tell everybody else in the
                     // scene that it's no longer in their awareness.
                     m_scene.ForEachClient(
                         client =>
                             { if (client.AgentId != so.AttachedAvatar)
-                                client.SendKillObject(m_scene.RegionInfo.RegionHandle, new List<uint>() { so.LocalId });
+                                client.SendKillObject(new List<uint>() { so.LocalId });
                             });
                 }
 
@@ -692,14 +900,15 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (m_invAccessModule == null)
                 return null;
 
-            //            m_log.DebugFormat(
-            //                "[ATTACHMENTS MODULE]: Called AddSceneObjectAsAttachment for object {0} {1} for {2}",
-            //                grp.Name, grp.LocalId, remoteClient.Name);
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Called AddSceneObjectAsAttachment for object {0} {1} for {2}",
+                    grp.Name, grp.LocalId, sp.Name);
 
             InventoryItemBase newItem
                 = m_invAccessModule.CopyToInventory(
                     DeRezAction.TakeCopy,
-                    m_scene.InventoryService.GetFolderForType(sp.UUID, AssetType.Object).ID,
+                    m_scene.InventoryService.GetFolderForType(sp.UUID, FolderType.Object).ID,
                     new List<SceneObjectGroup> { grp },
                     sp.ControllingClient, true)[0];
 
@@ -709,8 +918,32 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             return newItem;
         }
 
-        private string GetObjectScriptStates(SceneObjectGroup grp)
+        /// <summary>
+        /// Prepares the script instance for save.
+        /// </summary>
+        /// <remarks>
+        /// This involves triggering the detach event and getting the script state (which also stops the script)
+        /// This MUST be done outside sp.AttachmentsSyncLock, since otherwise there is a chance of deadlock if a 
+        /// running script is performing attachment operations.
+        /// </remarks>
+        /// <returns>
+        /// The script state ready for persistence.
+        /// </returns>
+        /// <param name='grp'>
+        /// </param>
+        /// <param name='fireDetachEvent'>
+        /// If true, then fire the script event before we save its state.
+        /// </param>
+        private string PrepareScriptInstanceForSave(SceneObjectGroup grp, bool fireDetachEvent)
         {
+            if (fireDetachEvent)
+            {
+                m_scene.EventManager.TriggerOnAttach(grp.LocalId, grp.FromItemID, UUID.Zero);
+
+                // Allow detach event time to do some work before stopping the script
+                Thread.Sleep(2);
+            }
+
             using (StringWriter sw = new StringWriter())
             {
                 using (XmlTextWriter writer = new XmlTextWriter(sw))
@@ -722,7 +955,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             }
         }
 
-        private void UpdateDetachedObject(IScenePresence sp, SceneObjectGroup so)
+        private void UpdateDetachedObject(IScenePresence sp, SceneObjectGroup so, string scriptedState)
         {
             // Don't save attachments for HG visitors, it
             // messes up their inventory. When a HG visitor logs
@@ -735,11 +968,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                     && (m_scene.UserManagementModule == null
                     || m_scene.UserManagementModule.IsLocalGridUser(sp.UUID));
 
-            // Scripts MUST be snapshotted before the object is
-            // removed from the scene because doing otherwise will
-            // clobber the run flag
-            string scriptedState = GetObjectScriptStates(so);
-
             // Remove the object from the scene so no more updates
             // are sent. Doing this before the below changes will ensure
             // updates can't cause "HUD artefacts"
@@ -763,91 +991,88 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             so.RemoveScriptInstances(true);
         }
 
-        private void DetachSingleAttachmentToInvInternal(IScenePresence sp, SceneObjectGroup so)
+        protected SceneObjectGroup RezSingleAttachmentFromInventoryInternal(
+            IScenePresence sp, UUID itemID, UUID assetID, uint attachmentPt, bool append)
         {
-            //            m_log.DebugFormat("[ATTACHMENTS MODULE]: Detaching item {0} to inventory for {1}", itemID, sp.Name);
+            if (m_invAccessModule == null)
+                return null;
 
-            m_scene.EventManager.TriggerOnAttach(so.LocalId, so.FromItemID, UUID.Zero);
-            sp.RemoveAttachment(so);
+            SceneObjectGroup objatt;
 
-            UpdateDetachedObject(sp, so);
-        }
+            if (itemID != UUID.Zero)
+                objatt = m_invAccessModule.RezObject(sp.ControllingClient,
+                    itemID, Vector3.Zero, Vector3.Zero, UUID.Zero, (byte)1, true,
+                    false, false, sp.UUID, true);
+            else
+                objatt = m_invAccessModule.RezObject(sp.ControllingClient,
+                    null, assetID, Vector3.Zero, Vector3.Zero, UUID.Zero, (byte)1, true,
+                    false, false, sp.UUID, true);
 
-        private SceneObjectGroup RezSingleAttachmentFromInventoryInternal(
-            IScenePresence sp, UUID itemID, UUID assetID, uint attachmentPt)
-        {
-            if (m_invAccessModule == null)
-                return null;
+            if (objatt == null)
+            {
+                m_log.WarnFormat(
+                    "[ATTACHMENTS MODULE]: Could not retrieve item {0} for attaching to avatar {1} at point {2}",
+                    itemID, sp.Name, attachmentPt);
 
-            lock (sp.AttachmentsSyncLock)
+                return null;
+            }
+            else if (itemID == UUID.Zero)
             {
-                SceneObjectGroup objatt;
+                // We need to have a FromItemID for multiple attachments on a single attach point to appear.  This is 
+                // true on Singularity 1.8.5 and quite possibly other viewers as well.  As NPCs don't have an inventory
+                // we will satisfy this requirement by inserting a random UUID.
+                objatt.FromItemID = UUID.Random();
+            }
 
-                if (itemID != UUID.Zero)
-                    objatt = m_invAccessModule.RezObject(sp.ControllingClient,
-                        itemID, Vector3.Zero, Vector3.Zero, UUID.Zero, (byte)1, true,
-                        false, false, sp.UUID, true);
-                else
-                    objatt = m_invAccessModule.RezObject(sp.ControllingClient,
-                        null, assetID, Vector3.Zero, Vector3.Zero, UUID.Zero, (byte)1, true,
-                        false, false, sp.UUID, true);
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Rezzed single object {0} with {1} prims for attachment to {2} on point {3} in {4}",
+                    objatt.Name, objatt.PrimCount, sp.Name, attachmentPt, m_scene.Name);
+
+            // HasGroupChanged is being set from within RezObject.  Ideally it would be set by the caller.
+            objatt.HasGroupChanged = false;
+            bool tainted = false;
+            if (attachmentPt != 0 && attachmentPt != objatt.AttachmentPoint)
+                tainted = true;
+
+            // FIXME: Detect whether it's really likely for AttachObject to throw an exception in the normal
+            // course of events.  If not, then it's probably not worth trying to recover the situation
+            // since this is more likely to trigger further exceptions and confuse later debugging.  If
+            // exceptions can be thrown in expected error conditions (not NREs) then make this consistent
+            // since other normal error conditions will simply return false instead.
+            // This will throw if the attachment fails
+            try
+            {
+                AttachObjectInternal(sp, objatt, attachmentPt, false, true, true, append);
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat(
+                    "[ATTACHMENTS MODULE]: Failed to attach {0} {1} for {2}, exception {3}{4}",
+                    objatt.Name, objatt.UUID, sp.Name, e.Message, e.StackTrace);
 
-                if (objatt != null)
-                {
-//                    m_log.DebugFormat(
-//                        "[ATTACHMENTS MODULE]: Rezzed single object {0} for attachment to {1} on point {2} in {3}",
-//                        objatt.Name, sp.Name, attachmentPt, m_scene.Name);
-
-                    // HasGroupChanged is being set from within RezObject.  Ideally it would be set by the caller.
-                    objatt.HasGroupChanged = false;
-                    bool tainted = false;
-                    if (attachmentPt != 0 && attachmentPt != objatt.AttachmentPoint)
-                        tainted = true;
-
-                    // FIXME: Detect whether it's really likely for AttachObject to throw an exception in the normal
-                    // course of events.  If not, then it's probably not worth trying to recover the situation
-                    // since this is more likely to trigger further exceptions and confuse later debugging.  If
-                    // exceptions can be thrown in expected error conditions (not NREs) then make this consistent
-                    // since other normal error conditions will simply return false instead.
-                    // This will throw if the attachment fails
-                    try
-                    {
-                        AttachObjectInternal(sp, objatt, attachmentPt, false, false);
-                    }
-                    catch (Exception e)
-                    {
-                        m_log.ErrorFormat(
-                            "[ATTACHMENTS MODULE]: Failed to attach {0} {1} for {2}, exception {3}{4}",
-                            objatt.Name, objatt.UUID, sp.Name, e.Message, e.StackTrace);
-
-                        // Make sure the object doesn't stick around and bail
-                        sp.RemoveAttachment(objatt);
-                        m_scene.DeleteSceneObject(objatt, false);
-                        return null;
-                    }
+                // Make sure the object doesn't stick around and bail
+                sp.RemoveAttachment(objatt);
+                m_scene.DeleteSceneObject(objatt, false);
+                return null;
+            }
 
-                    if (tainted)
-                        objatt.HasGroupChanged = true;
+            if (tainted)
+                objatt.HasGroupChanged = true;           
 
-                    // Fire after attach, so we don't get messy perms dialogs
-                    // 4 == AttachedRez
-                    objatt.CreateScriptInstances(0, true, m_scene.DefaultScriptEngine, 4);
-                    objatt.ResumeScripts();
+            if (ThrottlePer100PrimsRezzed > 0)
+            {
+                int throttleMs = (int)Math.Round((float)objatt.PrimCount / 100 * ThrottlePer100PrimsRezzed);
 
-                    // Do this last so that event listeners have access to all the effects of the attachment
-                    m_scene.EventManager.TriggerOnAttach(objatt.LocalId, itemID, sp.UUID);
+                if (DebugLevel > 0)
+                    m_log.DebugFormat(
+                        "[ATTACHMENTS MODULE]: Throttling by {0}ms after rez of {1} with {2} prims for attachment to {3} on point {4} in {5}",
+                        throttleMs, objatt.Name, objatt.PrimCount, sp.Name, attachmentPt, m_scene.Name);
 
-                    return objatt;
-                }
-                else
-                {
-                    m_log.WarnFormat(
-                        "[ATTACHMENTS MODULE]: Could not retrieve item {0} for attaching to avatar {1} at point {2}",
-                        itemID, sp.Name, attachmentPt);
-                }
+                Thread.Sleep(throttleMs);
             }
 
-            return null;
+            return objatt;
         }
 
         /// <summary>
@@ -857,7 +1082,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
         /// <param name="AttachmentPt"></param>
         /// <param name="itemID"></param>
         /// <param name="att"></param>
-        private void ShowAttachInUserInventory(IScenePresence sp, uint AttachmentPt, UUID itemID, SceneObjectGroup att)
+        private void ShowAttachInUserInventory(IScenePresence sp, uint AttachmentPt, UUID itemID, SceneObjectGroup att, bool append)
         {
 //            m_log.DebugFormat(
 //                "[USER INVENTORY]: Updating attachment {0} for {1} at {2} using item ID {3}",
@@ -880,12 +1105,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (item == null)
                 return;
 
-            bool changed = sp.Appearance.SetAttachment((int)AttachmentPt, itemID, item.AssetID);
+            int attFlag = append ? 0x80 : 0;
+            bool changed = sp.Appearance.SetAttachment((int)AttachmentPt | attFlag, itemID, item.AssetID);
             if (changed && m_scene.AvatarFactory != null)
             {
-//                m_log.DebugFormat(
-//                    "[ATTACHMENTS MODULE]: Queueing appearance save for {0}, attachment {1} point {2} in ShowAttachInUserInventory()",
-//                    sp.Name, att.Name, AttachmentPt);
+                if (DebugLevel > 0)
+                    m_log.DebugFormat(
+                        "[ATTACHMENTS MODULE]: Queueing appearance save for {0}, attachment {1} point {2} in ShowAttachInUserInventory()",
+                        sp.Name, att.Name, AttachmentPt);
 
                 m_scene.AvatarFactory.QueueAppearanceSave(sp.UUID);
             }
@@ -900,9 +1127,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (!Enabled)
                 return null;
 
-            //            m_log.DebugFormat(
-            //                "[ATTACHMENTS MODULE]: Rezzing attachment to point {0} from item {1} for {2}",
-            //                (AttachmentPoint)AttachmentPt, itemID, remoteClient.Name);
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Rezzing attachment to point {0} from item {1} for {2}",
+                    (AttachmentPoint)AttachmentPt, itemID, remoteClient.Name);
 
             ScenePresence sp = m_scene.GetScenePresence(remoteClient.AgentId);
 
@@ -933,9 +1161,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
         private void Client_OnObjectAttach(IClientAPI remoteClient, uint objectLocalID, uint AttachmentPt, bool silent)
         {
-//            m_log.DebugFormat(
-//                "[ATTACHMENTS MODULE]: Attaching object local id {0} to {1} point {2} from ground (silent = {3})",
-//                objectLocalID, remoteClient.Name, AttachmentPt, silent);
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[ATTACHMENTS MODULE]: Attaching object local id {0} to {1} point {2} from ground (silent = {3})",
+                    objectLocalID, remoteClient.Name, AttachmentPt, silent);
 
             if (!Enabled)
                 return;
@@ -964,12 +1193,20 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                     return;
                 }
 
-                // TODO: this short circuits multiple attachments functionality  in  LL viewer 2.1+ and should
-                // be removed when that functionality is implemented in opensim
+                bool append = (AttachmentPt & 0x80) != 0;
                 AttachmentPt &= 0x7f;
 
                 // Calls attach with a Zero position
-                AttachObject(sp, part.ParentGroup, AttachmentPt, false, false);
+                if (AttachObject(sp, part.ParentGroup, AttachmentPt, false, true, append))
+                {
+                    if (DebugLevel > 0)
+                        m_log.Debug(
+                            "[ATTACHMENTS MODULE]: Saving avatar attachment. AgentID: " + remoteClient.AgentId
+                            + ", AttachmentPoint: " + AttachmentPt);
+
+                    // Save avatar attachment information
+                    m_scene.EventManager.TriggerOnAttach(objectLocalID, part.ParentGroup.FromItemID, remoteClient.AgentId);
+                }
             }
             catch (Exception e)
             {
@@ -997,17 +1234,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             ScenePresence sp = m_scene.GetScenePresence(remoteClient.AgentId);
             if (sp != null)
             {
-                lock (sp.AttachmentsSyncLock)
+                List<SceneObjectGroup> attachments = sp.GetAttachments();
+
+                foreach (SceneObjectGroup group in attachments)
                 {
-                    List<SceneObjectGroup> attachments = sp.GetAttachments();
-    
-                    foreach (SceneObjectGroup group in attachments)
+                    if (group.FromItemID == itemID && group.FromItemID != UUID.Zero)
                     {
-                        if (group.FromItemID == itemID && group.FromItemID != UUID.Zero)
-                        {
-                            DetachSingleAttachmentToInv(sp, group);
-                            return;
-                        }
+                        DetachSingleAttachmentToInv(sp, group);
+                        return;
                     }
                 }
             }
diff --git a/OpenSim/Region/CoreModules/Avatar/Attachments/Tests/AttachmentsModuleTests.cs b/OpenSim/Region/CoreModules/Avatar/Attachments/Tests/AttachmentsModuleTests.cs
index 0ee01c7..0ac3add 100644
--- a/OpenSim/Region/CoreModules/Avatar/Attachments/Tests/AttachmentsModuleTests.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Attachments/Tests/AttachmentsModuleTests.cs
@@ -37,7 +37,8 @@ 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.CoreModules.Avatar.Attachments;
 using OpenSim.Region.CoreModules.Framework;
 using OpenSim.Region.CoreModules.Framework.EntityTransfer;
@@ -51,7 +52,6 @@ using OpenSim.Region.ScriptEngine.Interfaces;
 using OpenSim.Region.ScriptEngine.XEngine;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
 {
@@ -130,7 +130,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             config.AddConfig("Modules");
             config.Configs["Modules"].Set("InventoryAccessModule", "BasicInventoryAccessModule");
 
-            modules.Add(new AttachmentsModule());
+            AttachmentsModule attMod = new AttachmentsModule();
+            attMod.DebugLevel = 1;
+            modules.Add(attMod);
             modules.Add(new BasicInventoryAccessModule());
         }
 
@@ -195,9 +197,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             string attName = "att";
 
             SceneObjectGroup so = SceneHelpers.AddSceneObject(scene, attName, sp.UUID);
+            Assert.That(so.Backup, Is.True);
 
             m_numberOfAttachEventsFired = 0;
-            scene.AttachmentsModule.AttachObject(sp, so, (uint)AttachmentPoint.Chest, false, false);
+            scene.AttachmentsModule.AttachObject(sp, so, (uint)AttachmentPoint.Chest, false, true, false);
 
             // Check status on scene presence
             Assert.That(sp.HasAttachments(), Is.True);
@@ -209,6 +212,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             Assert.That(attSo.IsAttachment);
             Assert.That(attSo.UsesPhysics, Is.False);
             Assert.That(attSo.IsTemporary, Is.False);
+            Assert.That(attSo.Backup, Is.False);
 
             // Check item status
             Assert.That(
@@ -219,7 +223,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             Assert.That(attachmentItem, Is.Not.Null);
             Assert.That(attachmentItem.Name, Is.EqualTo(attName));
 
-            InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(sp.UUID, AssetType.Object);
+            InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(sp.UUID, FolderType.Object);
             Assert.That(attachmentItem.Folder, Is.EqualTo(targetFolder.ID));
 
             Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
@@ -228,6 +232,120 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(1));
         }
 
+        [Test]
+        public void TestWearAttachmentFromGround()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            Scene scene = CreateTestScene();
+            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
+            ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1);
+
+            SceneObjectGroup so2 = SceneHelpers.AddSceneObject(scene, "att2", sp.UUID);
+
+            {
+                SceneObjectGroup so = SceneHelpers.AddSceneObject(scene, "att1", sp.UUID);
+
+                m_numberOfAttachEventsFired = 0;
+                scene.AttachmentsModule.AttachObject(sp, so, (uint)AttachmentPoint.Default, false, true, false);
+
+                // Check status on scene presence
+                Assert.That(sp.HasAttachments(), Is.True);
+                List<SceneObjectGroup> attachments = sp.GetAttachments();
+                Assert.That(attachments.Count, Is.EqualTo(1));
+                SceneObjectGroup attSo = attachments[0];
+                Assert.That(attSo.Name, Is.EqualTo(so.Name));
+                Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.LeftHand));
+                Assert.That(attSo.IsAttachment);
+                Assert.That(attSo.UsesPhysics, Is.False);
+                Assert.That(attSo.IsTemporary, Is.False);
+
+                // Check item status
+                Assert.That(
+                    sp.Appearance.GetAttachpoint(attSo.FromItemID),
+                    Is.EqualTo((int)AttachmentPoint.LeftHand));
+
+                InventoryItemBase attachmentItem = scene.InventoryService.GetItem(new InventoryItemBase(attSo.FromItemID));
+                Assert.That(attachmentItem, Is.Not.Null);
+                Assert.That(attachmentItem.Name, Is.EqualTo(so.Name));
+
+                InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(sp.UUID, FolderType.Object);
+                Assert.That(attachmentItem.Folder, Is.EqualTo(targetFolder.ID));
+
+                Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(2));
+
+                // Check events
+                Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(1));
+            }
+
+            // Test wearing a different attachment from the ground.
+            {
+                scene.AttachmentsModule.AttachObject(sp, so2, (uint)AttachmentPoint.Default, false, true, false);
+
+                // Check status on scene presence
+                Assert.That(sp.HasAttachments(), Is.True);
+                List<SceneObjectGroup> attachments = sp.GetAttachments();
+                Assert.That(attachments.Count, Is.EqualTo(1));
+                SceneObjectGroup attSo = attachments[0];
+                Assert.That(attSo.Name, Is.EqualTo(so2.Name));
+                Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.LeftHand));
+                Assert.That(attSo.IsAttachment);
+                Assert.That(attSo.UsesPhysics, Is.False);
+                Assert.That(attSo.IsTemporary, Is.False);
+
+                // Check item status
+                Assert.That(
+                    sp.Appearance.GetAttachpoint(attSo.FromItemID),
+                    Is.EqualTo((int)AttachmentPoint.LeftHand));
+
+                InventoryItemBase attachmentItem = scene.InventoryService.GetItem(new InventoryItemBase(attSo.FromItemID));
+                Assert.That(attachmentItem, Is.Not.Null);
+                Assert.That(attachmentItem.Name, Is.EqualTo(so2.Name));
+
+                InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(sp.UUID, FolderType.Object);
+                Assert.That(attachmentItem.Folder, Is.EqualTo(targetFolder.ID));
+
+                Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
+
+                // Check events
+                Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(3));
+            }
+
+            // Test rewearing an already worn attachment from ground.  Nothing should happen.
+            {
+                scene.AttachmentsModule.AttachObject(sp, so2, (uint)AttachmentPoint.Default, false, true, false);
+
+                // Check status on scene presence
+                Assert.That(sp.HasAttachments(), Is.True);
+                List<SceneObjectGroup> attachments = sp.GetAttachments();
+                Assert.That(attachments.Count, Is.EqualTo(1));
+                SceneObjectGroup attSo = attachments[0];
+                Assert.That(attSo.Name, Is.EqualTo(so2.Name));
+                Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.LeftHand));
+                Assert.That(attSo.IsAttachment);
+                Assert.That(attSo.UsesPhysics, Is.False);
+                Assert.That(attSo.IsTemporary, Is.False);
+
+                // Check item status
+                Assert.That(
+                    sp.Appearance.GetAttachpoint(attSo.FromItemID),
+                    Is.EqualTo((int)AttachmentPoint.LeftHand));
+
+                InventoryItemBase attachmentItem = scene.InventoryService.GetItem(new InventoryItemBase(attSo.FromItemID));
+                Assert.That(attachmentItem, Is.Not.Null);
+                Assert.That(attachmentItem.Name, Is.EqualTo(so2.Name));
+
+                InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(sp.UUID, FolderType.Object);
+                Assert.That(attachmentItem.Folder, Is.EqualTo(targetFolder.ID));
+
+                Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
+
+                // Check events
+                Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(3));
+            }
+        }
+
         /// <summary>
         /// Test that we do not attempt to attach an in-world object that someone else is sitting on.
         /// </summary>
@@ -254,7 +372,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             sp2.AbsolutePosition = new Vector3(0, 0, 0);
             sp2.HandleAgentRequestSit(sp2.ControllingClient, sp2.UUID, so.UUID, Vector3.Zero);
 
-            scene.AttachmentsModule.AttachObject(sp, so, (uint)AttachmentPoint.Chest, false, false);
+            scene.AttachmentsModule.AttachObject(sp, so, (uint)AttachmentPoint.Chest, false, true, false);
 
             Assert.That(sp.HasAttachments(), Is.False);
             Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
@@ -267,7 +385,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
         public void TestRezAttachmentFromInventory()
         {
             TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
+//            TestHelpers.EnableLogging();
 
             Scene scene = CreateTestScene();
             UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
@@ -275,29 +393,141 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
 
             InventoryItemBase attItem = CreateAttachmentItem(scene, ua1.PrincipalID, "att", 0x10, 0x20);
 
-            m_numberOfAttachEventsFired = 0;
-            scene.AttachmentsModule.RezSingleAttachmentFromInventory(
-                sp, attItem.ID, (uint)AttachmentPoint.Chest);
+            {
+                scene.AttachmentsModule.RezSingleAttachmentFromInventory(
+                    sp, attItem.ID, (uint)AttachmentPoint.Chest);
 
-            // Check scene presence status
-            Assert.That(sp.HasAttachments(), Is.True);
-            List<SceneObjectGroup> attachments = sp.GetAttachments();
-            Assert.That(attachments.Count, Is.EqualTo(1));
-            SceneObjectGroup attSo = attachments[0];
-            Assert.That(attSo.Name, Is.EqualTo(attItem.Name));
-            Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.Chest));
-            Assert.That(attSo.IsAttachment);
-            Assert.That(attSo.UsesPhysics, Is.False);
-            Assert.That(attSo.IsTemporary, Is.False);
+                // Check scene presence status
+                Assert.That(sp.HasAttachments(), Is.True);
+                List<SceneObjectGroup> attachments = sp.GetAttachments();
+                Assert.That(attachments.Count, Is.EqualTo(1));
+                SceneObjectGroup attSo = attachments[0];
+                Assert.That(attSo.Name, Is.EqualTo(attItem.Name));
+                Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.Chest));
+                Assert.That(attSo.IsAttachment);
+                Assert.That(attSo.UsesPhysics, Is.False);
+                Assert.That(attSo.IsTemporary, Is.False);
+                Assert.IsFalse(attSo.Backup);
+
+                // Check appearance status
+                Assert.That(sp.Appearance.GetAttachments().Count, Is.EqualTo(1));
+                Assert.That(sp.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo((int)AttachmentPoint.Chest));
+                Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
+
+                // Check events
+                Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(1));
+            }
+
+            // Test attaching an already attached attachment
+            {
+                scene.AttachmentsModule.RezSingleAttachmentFromInventory(
+                    sp, attItem.ID, (uint)AttachmentPoint.Chest);
 
-            // Check appearance status
-            Assert.That(sp.Appearance.GetAttachments().Count, Is.EqualTo(1));
-            Assert.That(sp.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo((int)AttachmentPoint.Chest));
+                // Check scene presence status
+                Assert.That(sp.HasAttachments(), Is.True);
+                List<SceneObjectGroup> attachments = sp.GetAttachments();
+                Assert.That(attachments.Count, Is.EqualTo(1));
+                SceneObjectGroup attSo = attachments[0];
+                Assert.That(attSo.Name, Is.EqualTo(attItem.Name));
+                Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.Chest));
+                Assert.That(attSo.IsAttachment);
+                Assert.That(attSo.UsesPhysics, Is.False);
+                Assert.That(attSo.IsTemporary, Is.False);
+
+                // Check appearance status
+                Assert.That(sp.Appearance.GetAttachments().Count, Is.EqualTo(1));
+                Assert.That(sp.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo((int)AttachmentPoint.Chest));
+                Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
+
+                // Check events
+                Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(1));
+            }
+        }
 
-            Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
+        /// <summary>
+        /// Test wearing an attachment from inventory, as opposed to explicit choosing the rez point
+        /// </summary>
+        [Test]
+        public void TestWearAttachmentFromInventory()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
 
-            // Check events
-            Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(1));
+            Scene scene = CreateTestScene();
+            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
+            ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1.PrincipalID);
+
+            InventoryItemBase attItem1 = CreateAttachmentItem(scene, ua1.PrincipalID, "att1", 0x10, 0x20);
+            InventoryItemBase attItem2 = CreateAttachmentItem(scene, ua1.PrincipalID, "att2", 0x11, 0x21);
+
+            {
+                m_numberOfAttachEventsFired = 0;
+                scene.AttachmentsModule.RezSingleAttachmentFromInventory(sp, attItem1.ID, (uint)AttachmentPoint.Default);
+
+                // default attachment point is currently the left hand.
+                Assert.That(sp.HasAttachments(), Is.True);
+                List<SceneObjectGroup> attachments = sp.GetAttachments();
+                Assert.That(attachments.Count, Is.EqualTo(1));
+                SceneObjectGroup attSo = attachments[0];
+                Assert.That(attSo.Name, Is.EqualTo(attItem1.Name));
+                Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.LeftHand));
+                Assert.That(attSo.IsAttachment);
+
+                // Check appearance status
+                Assert.That(sp.Appearance.GetAttachments().Count, Is.EqualTo(1));
+                Assert.That(sp.Appearance.GetAttachpoint(attItem1.ID), Is.EqualTo((int)AttachmentPoint.LeftHand));
+                Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
+
+                // Check events
+                Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(1));
+            }
+
+            // Test wearing a second attachment at the same position
+            // Until multiple attachments at one point is implemented, this will remove the first attachment
+            // This test relies on both attachments having the same default attachment point (in this case LeftHand 
+            // since none other has been set).
+            {
+                scene.AttachmentsModule.RezSingleAttachmentFromInventory(sp, attItem2.ID, (uint)AttachmentPoint.Default);
+
+                // default attachment point is currently the left hand.
+                Assert.That(sp.HasAttachments(), Is.True);
+                List<SceneObjectGroup> attachments = sp.GetAttachments();
+                Assert.That(attachments.Count, Is.EqualTo(1));
+                SceneObjectGroup attSo = attachments[0];
+                Assert.That(attSo.Name, Is.EqualTo(attItem2.Name));
+                Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.LeftHand));
+                Assert.That(attSo.IsAttachment);
+
+                // Check appearance status
+                Assert.That(sp.Appearance.GetAttachments().Count, Is.EqualTo(1));
+                Assert.That(sp.Appearance.GetAttachpoint(attItem2.ID), Is.EqualTo((int)AttachmentPoint.LeftHand));
+                Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
+
+                // Check events
+                Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(3));
+            }
+
+            // Test wearing an already attached attachment
+            {
+                scene.AttachmentsModule.RezSingleAttachmentFromInventory(sp, attItem2.ID, (uint)AttachmentPoint.Default);
+
+                // default attachment point is currently the left hand.
+                Assert.That(sp.HasAttachments(), Is.True);
+                List<SceneObjectGroup> attachments = sp.GetAttachments();
+                Assert.That(attachments.Count, Is.EqualTo(1));
+                SceneObjectGroup attSo = attachments[0];
+                Assert.That(attSo.Name, Is.EqualTo(attItem2.Name));
+                Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.LeftHand));
+                Assert.That(attSo.IsAttachment);
+
+                // Check appearance status
+                Assert.That(sp.Appearance.GetAttachments().Count, Is.EqualTo(1));
+                Assert.That(sp.Appearance.GetAttachpoint(attItem2.ID), Is.EqualTo((int)AttachmentPoint.LeftHand));
+                Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
+
+                // Check events
+                Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(3));
+            }
         }
 
         /// <summary>
@@ -315,7 +545,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             SceneObjectGroup so = SceneHelpers.CreateSceneObject(1, sp.UUID, "att-name", 0x10);
             TaskInventoryItem scriptItem
                 = TaskInventoryHelpers.AddScript(
-                    scene,
+                    scene.AssetService,
                     so.RootPart,
                     "scriptItem",
                     "default { attach(key id) { if (id != NULL_KEY) { llSay(0, \"Hello World\"); } } }");
@@ -372,7 +602,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             Assert.That(scene.InventoryService.GetItem(new InventoryItemBase(attItem.ID)), Is.Null);
 
             // Check object in scene
-            Assert.That(scene.GetSceneObjectGroup("att"), Is.Not.Null);
+            SceneObjectGroup soInScene = scene.GetSceneObjectGroup("att");
+            Assert.That(soInScene, Is.Not.Null);
+            Assert.IsTrue(soInScene.Backup);
 
             // Check events
             Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(1));
@@ -426,7 +658,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             SceneObjectGroup so = SceneHelpers.CreateSceneObject(1, sp.UUID, "att-name", 0x10);
             TaskInventoryItem scriptTaskItem
                 = TaskInventoryHelpers.AddScript(
-                    scene,
+                    scene.AssetService,
                     so.RootPart,
                     "scriptItem",
                     "default { attach(key id) { if (id != NULL_KEY) { llSay(0, \"Hello World\"); } } }");
@@ -490,7 +722,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             SceneObjectGroup rezzedAtt = presence.GetAttachments()[0];
 
             m_numberOfAttachEventsFired = 0;
-            scene.IncomingCloseAgent(presence.UUID, false);
+            scene.CloseAgent(presence.UUID, false);
 
             // Check that we can't retrieve this attachment from the scene.
             Assert.That(scene.GetSceneObjectGroup(rezzedAtt.UUID), Is.Null);
@@ -503,7 +735,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
         public void TestRezAttachmentsOnAvatarEntrance()
         {
             TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
+//            TestHelpers.EnableLogging();
 
             Scene scene = CreateTestScene();
             UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
@@ -526,6 +758,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             Assert.That(attSo.IsAttachment);
             Assert.That(attSo.UsesPhysics, Is.False);
             Assert.That(attSo.IsTemporary, Is.False);
+            Assert.IsFalse(attSo.Backup);
 
             // Check appearance status
             List<AvatarAttachment> retreivedAttachments = presence.Appearance.GetAttachments();
@@ -569,12 +802,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(0));
         }
 
+/*
         [Test]
-        public void TestSameSimulatorNeighbouringRegionsTeleport()
+        public void TestSameSimulatorNeighbouringRegionsTeleportV1()
         {
             TestHelpers.InMethod();
 //            TestHelpers.EnableLogging();
 
+            BaseHttpServer httpServer = new BaseHttpServer(99999);
+            MainServer.AddHttpServer(httpServer);
+            MainServer.Instance = httpServer;
+
             AttachmentsModule attModA = new AttachmentsModule();
             AttachmentsModule attModB = new AttachmentsModule();
             EntityTransferModule etmA = new EntityTransferModule();
@@ -603,8 +841,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             SceneHelpers.SetupSceneModules(
                 sceneB, config, new CapabilitiesModule(), etmB, attModB, new BasicInventoryAccessModule());
 
+            // FIXME: Hack - this is here temporarily to revert back to older entity transfer behaviour
+            lscm.ServiceVersion = 0.1f;
+
             UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(sceneA, 0x1);
-            ScenePresence beforeTeleportSp = SceneHelpers.AddScenePresence(sceneA, ua1.PrincipalID, sh.SceneManager);
+
+            AgentCircuitData acd = SceneHelpers.GenerateAgentData(ua1.PrincipalID);
+            TestClient tc = new TestClient(acd, sceneA);
+            List<TestClient> destinationTestClients = new List<TestClient>();
+            EntityTransferHelpers.SetupInformClientOfNeighbourTriggersNeighbourClientCreate(tc, destinationTestClients);
+
+            ScenePresence beforeTeleportSp = SceneHelpers.AddScenePresence(sceneA, tc, acd);
             beforeTeleportSp.AbsolutePosition = new Vector3(30, 31, 32);
 
             InventoryItemBase attItem = CreateAttachmentItem(sceneA, ua1.PrincipalID, "att", 0x10, 0x20);
@@ -623,7 +870,119 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
                 teleportLookAt,
                 (uint)TeleportFlags.ViaLocation);
 
-            ((TestClient)beforeTeleportSp.ControllingClient).CompleteTeleportClientSide();
+            destinationTestClients[0].CompleteMovement();
+
+            // Check attachments have made it into sceneB
+            ScenePresence afterTeleportSceneBSp = sceneB.GetScenePresence(ua1.PrincipalID);
+
+            // This is appearance data, as opposed to actually rezzed attachments
+            List<AvatarAttachment> sceneBAttachments = afterTeleportSceneBSp.Appearance.GetAttachments();
+            Assert.That(sceneBAttachments.Count, Is.EqualTo(1));
+            Assert.That(sceneBAttachments[0].AttachPoint, Is.EqualTo((int)AttachmentPoint.Chest));
+            Assert.That(sceneBAttachments[0].ItemID, Is.EqualTo(attItem.ID));
+            Assert.That(sceneBAttachments[0].AssetID, Is.EqualTo(attItem.AssetID));
+            Assert.That(afterTeleportSceneBSp.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo((int)AttachmentPoint.Chest));
+
+            // This is the actual attachment
+            List<SceneObjectGroup> actualSceneBAttachments = afterTeleportSceneBSp.GetAttachments();
+            Assert.That(actualSceneBAttachments.Count, Is.EqualTo(1));
+            SceneObjectGroup actualSceneBAtt = actualSceneBAttachments[0];
+            Assert.That(actualSceneBAtt.Name, Is.EqualTo(attItem.Name));
+            Assert.That(actualSceneBAtt.AttachmentPoint, Is.EqualTo((uint)AttachmentPoint.Chest));
+            Assert.IsFalse(actualSceneBAtt.Backup);
+
+            Assert.That(sceneB.GetSceneObjectGroups().Count, Is.EqualTo(1));
+
+            // Check attachments have been removed from sceneA
+            ScenePresence afterTeleportSceneASp = sceneA.GetScenePresence(ua1.PrincipalID);
+
+            // Since this is appearance data, it is still present on the child avatar!
+            List<AvatarAttachment> sceneAAttachments = afterTeleportSceneASp.Appearance.GetAttachments();
+            Assert.That(sceneAAttachments.Count, Is.EqualTo(1));
+            Assert.That(afterTeleportSceneASp.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo((int)AttachmentPoint.Chest));
+
+            // This is the actual attachment, which should no longer exist
+            List<SceneObjectGroup> actualSceneAAttachments = afterTeleportSceneASp.GetAttachments();
+            Assert.That(actualSceneAAttachments.Count, Is.EqualTo(0));
+
+            Assert.That(sceneA.GetSceneObjectGroups().Count, Is.EqualTo(0));
+
+            // Check events
+            Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(0));
+        }
+*/
+
+        [Test]
+        public void TestSameSimulatorNeighbouringRegionsTeleportV2()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            BaseHttpServer httpServer = new BaseHttpServer(99999);
+            MainServer.AddHttpServer(httpServer);
+            MainServer.Instance = httpServer;
+
+            AttachmentsModule attModA = new AttachmentsModule();
+            AttachmentsModule attModB = new AttachmentsModule();
+            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);
+
+            modulesConfig.Set("InventoryAccessModule", "BasicInventoryAccessModule");
+
+            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, attModA, new BasicInventoryAccessModule());
+            SceneHelpers.SetupSceneModules(
+                sceneB, config, new CapabilitiesModule(), etmB, attModB, new BasicInventoryAccessModule());
+
+            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(sceneA, 0x1);
+
+            AgentCircuitData acd = SceneHelpers.GenerateAgentData(ua1.PrincipalID);
+            TestClient tc = new TestClient(acd, sceneA);
+            List<TestClient> destinationTestClients = new List<TestClient>();
+            EntityTransferHelpers.SetupInformClientOfNeighbourTriggersNeighbourClientCreate(tc, destinationTestClients);
+
+            ScenePresence beforeTeleportSp = SceneHelpers.AddScenePresence(sceneA, tc, acd);
+            beforeTeleportSp.AbsolutePosition = new Vector3(30, 31, 32);
+
+            Assert.That(destinationTestClients.Count, Is.EqualTo(1));
+            Assert.That(destinationTestClients[0], Is.Not.Null);
+
+            InventoryItemBase attItem = CreateAttachmentItem(sceneA, ua1.PrincipalID, "att", 0x10, 0x20);
+
+            sceneA.AttachmentsModule.RezSingleAttachmentFromInventory(
+                beforeTeleportSp, attItem.ID, (uint)AttachmentPoint.Chest);
+
+            Vector3 teleportPosition = new Vector3(10, 11, 12);
+            Vector3 teleportLookAt = new Vector3(20, 21, 22);
+
+            // 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);
+
+            m_numberOfAttachEventsFired = 0;
+            sceneA.RequestTeleportLocation(
+                beforeTeleportSp.ControllingClient,
+                sceneB.RegionInfo.RegionHandle,
+                teleportPosition,
+                teleportLookAt,
+                (uint)TeleportFlags.ViaLocation);
 
             // Check attachments have made it into sceneB
             ScenePresence afterTeleportSceneBSp = sceneB.GetScenePresence(ua1.PrincipalID);
@@ -642,6 +1001,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             SceneObjectGroup actualSceneBAtt = actualSceneBAttachments[0];
             Assert.That(actualSceneBAtt.Name, Is.EqualTo(attItem.Name));
             Assert.That(actualSceneBAtt.AttachmentPoint, Is.EqualTo((uint)AttachmentPoint.Chest));
+            Assert.IsFalse(actualSceneBAtt.Backup);
 
             Assert.That(sceneB.GetSceneObjectGroups().Count, Is.EqualTo(1));
 
@@ -663,4 +1023,4 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             Assert.That(m_numberOfAttachEventsFired, Is.EqualTo(0));
         }
     }
-}
\ No newline at end of file
+}