34 files changed, 5038 insertions, 1184 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
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
index 0a69979..cfb082b 100644
--- a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
@@ -40,6 +40,7 @@ using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
 
 using Mono.Addins;
+using PermissionMask = OpenSim.Framework.PermissionMask;
 
 namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 {
@@ -54,6 +55,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
         private int m_savetime = 5; // seconds to wait before saving changed appearance
         private int m_sendtime = 2; // seconds to wait before sending changed appearance
+        private bool m_reusetextures = false;
 
         private int m_checkTime = 500; // milliseconds to wait between checks for appearance updates
         private System.Timers.Timer m_updateTimer = new System.Timers.Timer();
@@ -72,6 +74,8 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             {
                 m_savetime = Convert.ToInt32(appearanceConfig.GetString("DelayBeforeAppearanceSave",Convert.ToString(m_savetime)));
                 m_sendtime = Convert.ToInt32(appearanceConfig.GetString("DelayBeforeAppearanceSend",Convert.ToString(m_sendtime)));
+                m_reusetextures = appearanceConfig.GetBoolean("ReuseTextures",m_reusetextures);
+                
                 // m_log.InfoFormat("[AVFACTORY] configured for {0} save and {1} send",m_savetime,m_sendtime);
             }
 
@@ -130,6 +134,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             client.OnRequestWearables += Client_OnRequestWearables;
             client.OnSetAppearance += Client_OnSetAppearance;
             client.OnAvatarNowWearing += Client_OnAvatarNowWearing;
+            client.OnCachedTextureRequest += Client_OnCachedTextureRequest;
         }
 
         #endregion
@@ -140,9 +145,24 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         /// <param name="sp"></param>
         /// <param name="texture"></param>
         /// <param name="visualParam"></param>
-        public void SetAppearance(IScenePresence sp, AvatarAppearance appearance)
+        public void SetAppearance(IScenePresence sp, AvatarAppearance appearance, WearableCacheItem[] cacheItems)
         {
-            SetAppearance(sp, appearance.Texture, appearance.VisualParams);
+            SetAppearance(sp, appearance.Texture, appearance.VisualParams, cacheItems);
+        }
+
+
+        public void SetAppearance(IScenePresence sp, Primitive.TextureEntry textureEntry, byte[] visualParams, Vector3 avSize, WearableCacheItem[] cacheItems)
+        {
+            float oldoff = sp.Appearance.AvatarFeetOffset;
+            Vector3 oldbox = sp.Appearance.AvatarBoxSize;
+
+            SetAppearance(sp, textureEntry, visualParams, cacheItems);
+            sp.Appearance.SetSize(avSize);
+
+            float off = sp.Appearance.AvatarFeetOffset;
+            Vector3 box = sp.Appearance.AvatarBoxSize;
+            if (oldoff != off || oldbox != box)
+                ((ScenePresence)sp).SetSize(box, off);
         }
 
         /// <summary>
@@ -151,7 +171,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         /// <param name="sp"></param>
         /// <param name="texture"></param>
         /// <param name="visualParam"></param>
-        public void SetAppearance(IScenePresence sp, Primitive.TextureEntry textureEntry, byte[] visualParams)
+        public void SetAppearance(IScenePresence sp, Primitive.TextureEntry textureEntry, byte[] visualParams, WearableCacheItem[] cacheItems)
         {
 //            m_log.DebugFormat(
 //                "[AVFACTORY]: start SetAppearance for {0}, te {1}, visualParams {2}",
@@ -174,18 +194,27 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                     //                    m_log.DebugFormat(
                     //                        "[AVFACTORY]: Setting visual params for {0} to {1}",
                     //                        client.Name, string.Join(", ", visualParamsStrings));
-
+/*
                     float oldHeight = sp.Appearance.AvatarHeight;
                     changed = sp.Appearance.SetVisualParams(visualParams);
 
                     if (sp.Appearance.AvatarHeight != oldHeight && sp.Appearance.AvatarHeight > 0)
                         ((ScenePresence)sp).SetHeight(sp.Appearance.AvatarHeight);
-                }
+ */
+//                    float oldoff = sp.Appearance.AvatarFeetOffset;
+//                    Vector3 oldbox = sp.Appearance.AvatarBoxSize;
+                    changed = sp.Appearance.SetVisualParams(visualParams);
+//                    float off = sp.Appearance.AvatarFeetOffset;
+//                    Vector3 box = sp.Appearance.AvatarBoxSize;
+//                    if(oldoff != off || oldbox != box)
+//                        ((ScenePresence)sp).SetSize(box,off);
 
+                }
+            
                 // Process the baked texture array
                 if (textureEntry != null)
                 {
-//                    m_log.DebugFormat("[AVFACTORY]: Received texture update for {0} {1}", sp.Name, sp.UUID);
+                    m_log.DebugFormat("[AVFACTORY]: Received texture update for {0} {1}", sp.Name, sp.UUID);
 
 //                    WriteBakedTexturesReport(sp, m_log.DebugFormat);
 
@@ -222,7 +251,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         private void SendAppearance(ScenePresence sp)
         {
             // Send the appearance to everyone in the scene
-            sp.SendAppearanceToAllOtherAgents();
+            sp.SendAppearanceToAllOtherClients();
 
             // Send animations back to the avatar as well
             sp.Animator.SendAnimPack();
@@ -254,6 +283,17 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             return GetBakedTextureFaces(sp);
         }
 
+        public WearableCacheItem[] GetCachedItems(UUID agentId)
+        {
+            ScenePresence sp = m_scene.GetScenePresence(agentId);
+            WearableCacheItem[] items = sp.Appearance.WearableCacheItems;
+            //foreach (WearableCacheItem item in items)
+            //{
+               
+            //}
+            return items;
+        }
+
         public bool SaveBakedTextures(UUID agentId)
         {
             ScenePresence sp = m_scene.GetScenePresence(agentId);
@@ -287,6 +327,9 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
                 if (asset != null)
                 {
+                    // Replace an HG ID with the simple asset ID so that we can persist textures for foreign HG avatars
+                    asset.ID = asset.FullID.ToString();
+
                     asset.Temporary = false;
                     asset.Local = false;
                     m_scene.AssetService.Store(asset);
@@ -323,7 +366,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
         public void QueueAppearanceSave(UUID agentid)
         {
-            // m_log.WarnFormat("[AVFACTORY]: Queue appearance save for {0}", agentid);
+//            m_log.DebugFormat("[AVFACTORY]: Queueing appearance save for {0}", agentid);
 
             // 10000 ticks per millisecond, 1000 milliseconds per second
             long timestamp = DateTime.Now.Ticks + Convert.ToInt64(m_savetime * 1000 * 10000);
@@ -337,6 +380,53 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         public bool ValidateBakedTextureCache(IScenePresence sp)
         {
             bool defonly = true; // are we only using default textures
+            IImprovedAssetCache cache = m_scene.RequestModuleInterface<IImprovedAssetCache>();
+            IBakedTextureModule bakedModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
+            WearableCacheItem[] wearableCache = null;
+
+            // Cache wearable data for teleport.
+            // Only makes sense if there's a bake module and a cache module
+            if (bakedModule != null && cache != null)
+            {
+                try
+                {
+                    wearableCache = bakedModule.Get(sp.UUID);
+                }
+                catch (Exception)
+                {
+
+                }
+                if (wearableCache != null)
+                {
+                    for (int i = 0; i < wearableCache.Length; i++)
+                    {
+                       cache.Cache(wearableCache[i].TextureAsset);
+                    }
+                }
+            }
+            /*
+             IBakedTextureModule bakedModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
+            if (invService.GetRootFolder(userID) != null)
+            {
+                WearableCacheItem[] wearableCache = null;
+                if (bakedModule != null)
+                {
+                    try
+                    {
+                        wearableCache = bakedModule.Get(userID);
+                        appearance.WearableCacheItems = wearableCache;
+                        appearance.WearableCacheItemsDirty = false;
+                        foreach (WearableCacheItem item in wearableCache)
+                        {
+                            appearance.Texture.FaceTextures[item.TextureIndex].TextureID = item.TextureID;
+                        }
+                    }
+                    catch (Exception)
+                    {
+                        
+                    }
+                }
+             */
 
             // Process the texture entry
             for (int i = 0; i < AvatarAppearance.BAKE_INDICES.Length; i++)
@@ -344,10 +434,32 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                 int idx = AvatarAppearance.BAKE_INDICES[i];
                 Primitive.TextureEntryFace face = sp.Appearance.Texture.FaceTextures[idx];
 
-                // if there is no texture entry, skip it
+                // No face, so lets check our baked service cache, teleport or login.
                 if (face == null)
-                    continue;
-
+                {
+                    if (wearableCache != null)
+                    {
+                        // If we find the an appearance item, set it as the textureentry and the face
+                        WearableCacheItem searchitem = WearableCacheItem.SearchTextureIndex((uint) idx, wearableCache);
+                        if (searchitem != null)
+                        {
+                            sp.Appearance.Texture.FaceTextures[idx] = sp.Appearance.Texture.CreateFace((uint) idx);
+                            sp.Appearance.Texture.FaceTextures[idx].TextureID = searchitem.TextureID;
+                            face = sp.Appearance.Texture.FaceTextures[idx];
+                        }
+                        else
+                        {
+                            // if there is no texture entry and no baked cache, skip it
+                            continue;
+                        }
+                    }
+                    else
+                    {
+                        //No texture entry face and no cache.  Skip this face.
+                        continue;
+                    }
+                }
+                    
 //                m_log.DebugFormat(
 //                    "[AVFACTORY]: Looking for texture {0}, id {1} for {2} {3}",
 //                    face.TextureID, idx, client.Name, client.AgentId);
@@ -374,6 +486,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         public int RequestRebake(IScenePresence sp, bool missingTexturesOnly)
         {
             int texturesRebaked = 0;
+//            IImprovedAssetCache cache = m_scene.RequestModuleInterface<IImprovedAssetCache>();
 
             for (int i = 0; i < AvatarAppearance.BAKE_INDICES.Length; i++)
             {
@@ -480,7 +593,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
                     if (sendTime < now)
                     {
-                        Util.FireAndForget(o => SendAppearance(avatarID));
+                        Util.FireAndForget(o => SendAppearance(avatarID), null, "AvatarFactoryModule.SendAppearance");
                         m_sendqueue.Remove(avatarID);
                     }
                 }
@@ -498,7 +611,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
                     if (sendTime < now)
                     {
-                        Util.FireAndForget(o => SaveAppearance(avatarID));
+                        Util.FireAndForget(o => SaveAppearance(avatarID), null, "AvatarFactoryModule.SaveAppearance");
                         m_savequeue.Remove(avatarID);
                     }
                 }
@@ -526,7 +639,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                 return;
             }
 
-            // m_log.WarnFormat("[AVFACTORY] avatar {0} save appearance",agentid);
+//            m_log.DebugFormat("[AVFACTORY]: Saving appearance for avatar {0}", agentid);
 
             // This could take awhile since it needs to pull inventory
             // We need to do it at the point of save so that there is a sufficient delay for any upload of new body part/shape
@@ -535,6 +648,14 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             // multiple save requests.
             SetAppearanceAssets(sp.UUID, sp.Appearance);
 
+//            List<AvatarAttachment> attachments = sp.Appearance.GetAttachments();
+//            foreach (AvatarAttachment att in attachments)
+//            {
+//                m_log.DebugFormat(
+//                    "[AVFACTORY]: For {0} saving attachment {1} at point {2}",
+//                    sp.Name, att.ItemID, att.AttachPoint);
+//            }
+
             m_scene.AvatarService.SetAppearance(agentid, sp.Appearance);
 
             // Trigger this here because it's the final step in the set/queue/save process for appearance setting. 
@@ -542,6 +663,12 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             m_scene.EventManager.TriggerAvatarAppearanceChanged(sp);
         }
 
+        /// <summary>
+        /// For a given set of appearance items, check whether the items are valid and add their asset IDs to 
+        /// appearance data.
+        /// </summary>
+        /// <param name='userID'></param>
+        /// <param name='appearance'></param>
         private void SetAppearanceAssets(UUID userID, AvatarAppearance appearance)
         {
             IInventoryService invService = m_scene.InventoryService;
@@ -553,7 +680,13 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                     for (int j = 0; j < appearance.Wearables[i].Count; j++)
                     {
                         if (appearance.Wearables[i][j].ItemID == UUID.Zero)
+                        {
+                            m_log.WarnFormat(
+                                "[AVFACTORY]: Wearable item {0}:{1} for user {2} unexpectedly UUID.Zero.  Ignoring.", 
+                                i, j, userID);
+
                             continue;
+                        }
 
                         // Ignore ruth's assets
                         if (appearance.Wearables[i][j].ItemID == AvatarWearable.DefaultWearables[i][0].ItemID)
@@ -568,7 +701,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                         }
                         else
                         {
-                            m_log.ErrorFormat(
+                            m_log.WarnFormat(
                                 "[AVFACTORY]: Can't find inventory item {0} for {1}, setting to default",
                                 appearance.Wearables[i][j].ItemID, (WearableType)i);
 
@@ -581,8 +714,311 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             {
                 m_log.WarnFormat("[AVFACTORY]: user {0} has no inventory, appearance isn't going to work", userID);
             }
+
+//            IInventoryService invService = m_scene.InventoryService;
+//            bool resetwearable = false;
+//            if (invService.GetRootFolder(userID) != null)
+//            {
+//                for (int i = 0; i < AvatarWearable.MAX_WEARABLES; i++)
+//                {
+//                    for (int j = 0; j < appearance.Wearables[i].Count; j++)
+//                    {
+//                        // Check if the default wearables are not set
+//                        if (appearance.Wearables[i][j].ItemID == UUID.Zero)
+//                        {
+//                            switch ((WearableType) i)
+//                            {
+//                                case WearableType.Eyes:
+//                                case WearableType.Hair:
+//                                case WearableType.Shape:
+//                                case WearableType.Skin:
+//                                //case WearableType.Underpants:
+//                                    TryAndRepairBrokenWearable((WearableType)i, invService, userID, appearance);
+//                                    resetwearable = true;
+//                                    m_log.Warn("[AVFACTORY]: UUID.Zero Wearables, passing fake values.");
+//                                    resetwearable = true;
+//                                    break;
+//
+//                            }
+//                            continue;
+//                        }
+//
+//                        // Ignore ruth's assets except for the body parts! missing body parts fail avatar appearance on V1
+//                        if (appearance.Wearables[i][j].ItemID == AvatarWearable.DefaultWearables[i][0].ItemID)
+//                        {
+//                            switch ((WearableType)i)
+//                            {
+//                                case WearableType.Eyes:
+//                                case WearableType.Hair:
+//                                case WearableType.Shape:
+//                                case WearableType.Skin:
+//                                //case WearableType.Underpants:
+//                                    TryAndRepairBrokenWearable((WearableType)i, invService, userID, appearance);
+//                            
+//                                    m_log.WarnFormat("[AVFACTORY]: {0} Default Wearables, passing existing values.", (WearableType)i);
+//                                    resetwearable = true;
+//                                    break;
+//
+//                            }
+//                            continue;
+//                        }
+//                        
+//                        InventoryItemBase baseItem = new InventoryItemBase(appearance.Wearables[i][j].ItemID, userID);
+//                        baseItem = invService.GetItem(baseItem);
+//
+//                        if (baseItem != null)
+//                        {
+//                            appearance.Wearables[i].Add(appearance.Wearables[i][j].ItemID, baseItem.AssetID);
+//                            int unmodifiedWearableIndexForClosure = i;
+//                            m_scene.AssetService.Get(baseItem.AssetID.ToString(), this,
+//                                                                      delegate(string x, object y, AssetBase z)
+//                                                                      {
+//                                                                          if (z == null)
+//                                                                          {
+//                                                                              TryAndRepairBrokenWearable(
+//                                                                                  (WearableType)unmodifiedWearableIndexForClosure, invService,
+//                                                                                  userID, appearance);
+//                                                                          }
+//                                                                      });
+//                        }
+//                        else
+//                        {
+//                            m_log.ErrorFormat(
+//                                "[AVFACTORY]: Can't find inventory item {0} for {1}, setting to default",
+//                                appearance.Wearables[i][j].ItemID, (WearableType)i);
+//
+//                            TryAndRepairBrokenWearable((WearableType)i, invService, userID, appearance);
+//                            resetwearable = true;
+//                            
+//                        }
+//                    }
+//                }
+//
+//                // I don't know why we have to test for this again...  but the above switches do not capture these scenarios for some reason....
+//                if (appearance.Wearables[(int) WearableType.Eyes] == null)
+//                {
+//                    m_log.WarnFormat("[AVFACTORY]: {0} Eyes are Null, passing existing values.", (WearableType.Eyes));
+//                    
+//                    TryAndRepairBrokenWearable(WearableType.Eyes, invService, userID, appearance);
+//                    resetwearable = true;
+//                }
+//                else
+//                {
+//                    if (appearance.Wearables[(int) WearableType.Eyes][0].ItemID == UUID.Zero)
+//                    {
+//                        m_log.WarnFormat("[AVFACTORY]: Eyes are UUID.Zero are broken, {0} {1}",
+//                                         appearance.Wearables[(int) WearableType.Eyes][0].ItemID,
+//                                         appearance.Wearables[(int) WearableType.Eyes][0].AssetID);
+//                        TryAndRepairBrokenWearable(WearableType.Eyes, invService, userID, appearance);
+//                        resetwearable = true;
+//
+//                    }
+//
+//                }
+//                // I don't know why we have to test for this again...  but the above switches do not capture these scenarios for some reason....
+//                if (appearance.Wearables[(int)WearableType.Shape] == null)
+//                {
+//                    m_log.WarnFormat("[AVFACTORY]: {0} shape is Null, passing existing values.", (WearableType.Shape));
+//
+//                    TryAndRepairBrokenWearable(WearableType.Shape, invService, userID, appearance);
+//                    resetwearable = true;
+//                }
+//                else
+//                {
+//                    if (appearance.Wearables[(int)WearableType.Shape][0].ItemID == UUID.Zero)
+//                    {
+//                        m_log.WarnFormat("[AVFACTORY]: Shape is UUID.Zero and broken, {0} {1}",
+//                                         appearance.Wearables[(int)WearableType.Shape][0].ItemID,
+//                                         appearance.Wearables[(int)WearableType.Shape][0].AssetID);
+//                        TryAndRepairBrokenWearable(WearableType.Shape, invService, userID, appearance);
+//                        resetwearable = true;
+//
+//                    }
+//
+//                }
+//                // I don't know why we have to test for this again...  but the above switches do not capture these scenarios for some reason....
+//                if (appearance.Wearables[(int)WearableType.Hair] == null)
+//                {
+//                    m_log.WarnFormat("[AVFACTORY]: {0} Hair is Null, passing existing values.", (WearableType.Hair));
+//
+//                    TryAndRepairBrokenWearable(WearableType.Hair, invService, userID, appearance);
+//                    resetwearable = true;
+//                }
+//                else
+//                {
+//                    if (appearance.Wearables[(int)WearableType.Hair][0].ItemID == UUID.Zero)
+//                    {
+//                        m_log.WarnFormat("[AVFACTORY]: Hair is UUID.Zero and broken, {0} {1}",
+//                                         appearance.Wearables[(int)WearableType.Hair][0].ItemID,
+//                                         appearance.Wearables[(int)WearableType.Hair][0].AssetID);
+//                        TryAndRepairBrokenWearable(WearableType.Hair, invService, userID, appearance);
+//                        resetwearable = true;
+//
+//                    }
+//
+//                }
+//                // I don't know why we have to test for this again...  but the above switches do not capture these scenarios for some reason....
+//                if (appearance.Wearables[(int)WearableType.Skin] == null)
+//                {
+//                    m_log.WarnFormat("[AVFACTORY]: {0} Skin is Null, passing existing values.", (WearableType.Skin));
+//
+//                    TryAndRepairBrokenWearable(WearableType.Skin, invService, userID, appearance);
+//                    resetwearable = true;
+//                }
+//                else
+//                {
+//                    if (appearance.Wearables[(int)WearableType.Skin][0].ItemID == UUID.Zero)
+//                    {
+//                        m_log.WarnFormat("[AVFACTORY]: Skin is UUID.Zero and broken, {0} {1}",
+//                                         appearance.Wearables[(int)WearableType.Skin][0].ItemID,
+//                                         appearance.Wearables[(int)WearableType.Skin][0].AssetID);
+//                        TryAndRepairBrokenWearable(WearableType.Skin, invService, userID, appearance);
+//                        resetwearable = true;
+//
+//                    }
+//
+//                }
+//                if (resetwearable)
+//                {
+//                    ScenePresence presence = null;
+//                    if (m_scene.TryGetScenePresence(userID, out presence))
+//                    {
+//                        presence.ControllingClient.SendWearables(presence.Appearance.Wearables,
+//                                                                 presence.Appearance.Serial++);
+//                    }
+//                }
+//
+//            }
+//            else
+//            {
+//                m_log.WarnFormat("[AVFACTORY]: user {0} has no inventory, appearance isn't going to work", userID);
+//            }
+        }
+
+        private void TryAndRepairBrokenWearable(WearableType type, IInventoryService invService, UUID userID,AvatarAppearance appearance)
+        {
+            UUID defaultwearable = GetDefaultItem(type);
+            if (defaultwearable != UUID.Zero)
+            {
+                UUID newInvItem = UUID.Random();
+                InventoryItemBase itembase = new InventoryItemBase(newInvItem, userID)
+                                                 {
+                                                     AssetID =
+                                                         defaultwearable,
+                                                     AssetType
+                                                         =
+                                                         (int)
+                                                         FolderType
+                                                             .BodyPart,
+                                                     CreatorId
+                                                         =
+                                                         userID
+                                                         .ToString
+                                                         (),
+                                                     //InvType = (int)InventoryType.Wearable,
+
+                                                     Description
+                                                         =
+                                                         "Failed Wearable Replacement",
+                                                     Folder =
+                                                         invService
+                                                         .GetFolderForType
+                                                         (userID,
+                                                          FolderType
+                                                              .BodyPart)
+                                                         .ID,
+                                                     Flags = (uint) type,
+                                                     Name = Enum.GetName(typeof (WearableType), type),
+                                                     BasePermissions = (uint) PermissionMask.Copy,
+                                                     CurrentPermissions = (uint) PermissionMask.Copy,
+                                                     EveryOnePermissions = (uint) PermissionMask.Copy,
+                                                     GroupPermissions = (uint) PermissionMask.Copy,
+                                                     NextPermissions = (uint) PermissionMask.Copy
+                                                 };
+                invService.AddItem(itembase);
+                UUID LinkInvItem = UUID.Random();
+                itembase = new InventoryItemBase(LinkInvItem, userID)
+                               {
+                                   AssetID =
+                                       newInvItem,
+                                   AssetType
+                                       =
+                                       (int)
+                                       AssetType
+                                           .Link,
+                                   CreatorId
+                                       =
+                                       userID
+                                       .ToString
+                                       (),
+                                   InvType = (int) InventoryType.Wearable,
+
+                                   Description
+                                       =
+                                       "Failed Wearable Replacement",
+                                   Folder =
+                                       invService
+                                       .GetFolderForType
+                                       (userID,
+                                        FolderType
+                                            .CurrentOutfit)
+                                       .ID,
+                                   Flags = (uint) type,
+                                   Name = Enum.GetName(typeof (WearableType), type),
+                                   BasePermissions = (uint) PermissionMask.Copy,
+                                   CurrentPermissions = (uint) PermissionMask.Copy,
+                                   EveryOnePermissions = (uint) PermissionMask.Copy,
+                                   GroupPermissions = (uint) PermissionMask.Copy,
+                                   NextPermissions = (uint) PermissionMask.Copy
+                               };
+                invService.AddItem(itembase);
+                appearance.Wearables[(int)type] = new AvatarWearable(newInvItem, GetDefaultItem(type));
+                ScenePresence presence = null;
+                if (m_scene.TryGetScenePresence(userID, out presence))
+                {
+                    m_scene.SendInventoryUpdate(presence.ControllingClient,
+                                                invService.GetFolderForType(userID,
+                                                                            FolderType
+                                                                                .CurrentOutfit),
+                                                false, true);
+                }
+            }
         }
 
+        private UUID GetDefaultItem(WearableType wearable)
+        {
+            // These are ruth
+            UUID ret = UUID.Zero;
+            switch (wearable)
+            {
+                case WearableType.Eyes:
+                    ret = new UUID("4bb6fa4d-1cd2-498a-a84c-95c1a0e745a7");
+                    break;
+                case WearableType.Hair:
+                    ret = new UUID("d342e6c0-b9d2-11dc-95ff-0800200c9a66");
+                    break;
+                case WearableType.Pants:
+                    ret = new UUID("00000000-38f9-1111-024e-222222111120");
+                    break;
+                case WearableType.Shape:
+                    ret = new UUID("66c41e39-38f9-f75a-024e-585989bfab73");
+                    break;
+                case WearableType.Shirt:
+                    ret = new UUID("00000000-38f9-1111-024e-222222111110");
+                    break;
+                case WearableType.Skin:
+                    ret = new UUID("77c41e39-38f9-f75a-024e-585989bbabbb");
+                    break;
+                case WearableType.Undershirt:
+                    ret = new UUID("16499ebb-3208-ec27-2def-481881728f47");
+                    break;
+                case WearableType.Underpants:
+                    ret = new UUID("4ac2e9c7-3671-d229-316a-67717730841d");
+                    break;
+            }
+
+            return ret;
+        }
         #endregion
 
         #region Client Event Handlers
@@ -592,12 +1028,17 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         /// <param name="client"></param>
         private void Client_OnRequestWearables(IClientAPI client)
         {
-            // m_log.DebugFormat("[AVFACTORY]: Client_OnRequestWearables called for {0} ({1})", client.Name, client.AgentId);
-            ScenePresence sp = m_scene.GetScenePresence(client.AgentId);
-            if (sp != null)
-                client.SendWearables(sp.Appearance.Wearables, sp.Appearance.Serial++);
-            else
-                m_log.WarnFormat("[AVFACTORY]: Client_OnRequestWearables unable to find presence for {0}", client.AgentId);
+            Util.FireAndForget(delegate(object x)
+            {
+                Thread.Sleep(4000);
+
+                // m_log.DebugFormat("[AVFACTORY]: Client_OnRequestWearables called for {0} ({1})", client.Name, client.AgentId);
+                ScenePresence sp = m_scene.GetScenePresence(client.AgentId);
+                if (sp != null)
+                    client.SendWearables(sp.Appearance.Wearables, sp.Appearance.Serial++);
+                else
+                    m_log.WarnFormat("[AVFACTORY]: Client_OnRequestWearables unable to find presence for {0}", client.AgentId);
+            }, null, "AvatarFactoryModule.OnClientRequestWearables");
         }
         
         /// <summary>
@@ -606,12 +1047,12 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         /// <param name="client"></param>
         /// <param name="texture"></param>
         /// <param name="visualParam"></param>
-        private void Client_OnSetAppearance(IClientAPI client, Primitive.TextureEntry textureEntry, byte[] visualParams)
+        private void Client_OnSetAppearance(IClientAPI client, Primitive.TextureEntry textureEntry, byte[] visualParams, Vector3 avSize, WearableCacheItem[] cacheItems)
         {
             // m_log.WarnFormat("[AVFACTORY]: Client_OnSetAppearance called for {0} ({1})", client.Name, client.AgentId);
             ScenePresence sp = m_scene.GetScenePresence(client.AgentId);
             if (sp != null)
-                SetAppearance(sp, textureEntry, visualParams);
+                SetAppearance(sp, textureEntry, visualParams,avSize, cacheItems);
             else
                 m_log.WarnFormat("[AVFACTORY]: Client_OnSetAppearance unable to find presence for {0}", client.AgentId);
         }
@@ -659,6 +1100,61 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                 QueueAppearanceSave(client.AgentId);
             }
         }
+
+        /// <summary>
+        /// Respond to the cached textures request from the client
+        /// </summary>
+        /// <param name="client"></param>
+        /// <param name="serial"></param>
+        /// <param name="cachedTextureRequest"></param>
+        private void Client_OnCachedTextureRequest(IClientAPI client, int serial, List<CachedTextureRequestArg> cachedTextureRequest)
+        {
+            // m_log.WarnFormat("[AVFACTORY]: Client_OnCachedTextureRequest called for {0} ({1})", client.Name, client.AgentId);
+            ScenePresence sp = m_scene.GetScenePresence(client.AgentId);
+
+            List<CachedTextureResponseArg> cachedTextureResponse = new List<CachedTextureResponseArg>();
+            foreach (CachedTextureRequestArg request in cachedTextureRequest)
+            {
+                UUID texture = UUID.Zero;
+                int index = request.BakedTextureIndex;
+                
+                if (m_reusetextures)
+                {
+                    // this is the most insanely dumb way to do this... however it seems to
+                    // actually work. if the appearance has been reset because wearables have
+                    // changed then the texture entries are zero'd out until the bakes are 
+                    // uploaded. on login, if the textures exist in the cache (eg if you logged
+                    // into the simulator recently, then the appearance will pull those and send
+                    // them back in the packet and you won't have to rebake. if the textures aren't
+                    // in the cache then the intial makeroot() call in scenepresence will zero
+                    // them out.
+                    //
+                    // a better solution (though how much better is an open question) is to
+                    // store the hashes in the appearance and compare them. Thats's coming.
+
+                    Primitive.TextureEntryFace face = sp.Appearance.Texture.FaceTextures[index];
+                    if (face != null)
+                        texture = face.TextureID;
+
+                    // m_log.WarnFormat("[AVFACTORY]: reuse texture {0} for index {1}",texture,index);
+                }
+                
+                CachedTextureResponseArg response = new CachedTextureResponseArg();
+                response.BakedTextureIndex = index;
+                response.BakedTextureID = texture;
+                response.HostName = null;
+
+                cachedTextureResponse.Add(response);
+            }
+            
+            // m_log.WarnFormat("[AVFACTORY]: serial is {0}",serial);
+            // The serial number appears to be used to match requests and responses
+            // in the texture transaction. We just send back the serial number
+            // that was provided in the request. The viewer bumps this for us.
+            client.SendCachedTextureResponse(sp, serial, cachedTextureResponse);
+        }
+
+
         #endregion
 
         public void WriteBakedTexturesReport(IScenePresence sp, ReportOutputAction outputAction)
@@ -690,7 +1186,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             }
 
             bool bakedTextureValid = m_scene.AvatarFactory.ValidateBakedTextureCache(sp);
-            outputAction("{0} baked appearance texture is {1}", sp.Name, bakedTextureValid ? "OK" : "corrupt");
+            outputAction("{0} baked appearance texture is {1}", sp.Name, bakedTextureValid ? "OK" : "incomplete");
         }
     }
 }
diff --git a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/Tests/AvatarFactoryModuleTests.cs b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/Tests/AvatarFactoryModuleTests.cs
index 1830d41..9513408 100644
--- a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/Tests/AvatarFactoryModuleTests.cs
+++ b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/Tests/AvatarFactoryModuleTests.cs
@@ -34,7 +34,6 @@ using OpenSim.Framework;
 using OpenSim.Region.CoreModules.Asset;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 {
@@ -48,23 +47,103 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         public void TestSetAppearance()
         {
             TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
+//            TestHelpers.EnableLogging();
 
             UUID userId = TestHelpers.ParseTail(0x1);
+            UUID bakedTextureID = TestHelpers.ParseTail(0x2);
 
+            // We need an asset cache because otherwise the LocalAssetServiceConnector will short-circuit directly
+            // to the AssetService, which will then store temporary and local assets permanently
+            CoreAssetCache assetCache = new CoreAssetCache();
+            
             AvatarFactoryModule afm = new AvatarFactoryModule();
-            TestScene scene = new SceneHelpers().SetupScene();
+            TestScene scene = new SceneHelpers(assetCache).SetupScene();
             SceneHelpers.SetupSceneModules(scene, afm);
             ScenePresence sp = SceneHelpers.AddScenePresence(scene, userId);
 
+            // TODO: Use the actual BunchOfCaps functionality once we slot in the CapabilitiesModules
+            AssetBase bakedTextureAsset;
+            bakedTextureAsset 
+                = new AssetBase(
+                    bakedTextureID, "Test Baked Texture", (sbyte)AssetType.Texture, userId.ToString());
+            bakedTextureAsset.Data = new byte[] { 2 }; // Not necessary to have a genuine JPEG2000 asset here yet
+            bakedTextureAsset.Temporary = true;
+            bakedTextureAsset.Local = true;
+            scene.AssetService.Store(bakedTextureAsset);
+
             byte[] visualParams = new byte[AvatarAppearance.VISUALPARAM_COUNT];
             for (byte i = 0; i < visualParams.Length; i++)
                 visualParams[i] = i;
 
-            afm.SetAppearance(sp, new Primitive.TextureEntry(TestHelpers.ParseTail(0x10)), visualParams);
+            Primitive.TextureEntry bakedTextureEntry = new Primitive.TextureEntry(TestHelpers.ParseTail(0x10));
+            uint eyesFaceIndex = (uint)AppearanceManager.BakeTypeToAgentTextureIndex(BakeType.Eyes);
+            Primitive.TextureEntryFace eyesFace = bakedTextureEntry.CreateFace(eyesFaceIndex);
+
+            int rebakeRequestsReceived = 0;
+            ((TestClient)sp.ControllingClient).OnReceivedSendRebakeAvatarTextures += id => rebakeRequestsReceived++;
+
+            // This is the alpha texture
+            eyesFace.TextureID = bakedTextureID;
+            afm.SetAppearance(sp, bakedTextureEntry, visualParams, null);
+    
+            Assert.That(rebakeRequestsReceived, Is.EqualTo(0));
+
+            AssetBase eyesBake = scene.AssetService.Get(bakedTextureID.ToString());
+            Assert.That(eyesBake, Is.Not.Null);
+            Assert.That(eyesBake.Temporary, Is.True);
+            Assert.That(eyesBake.Local, Is.True);
+        }
+
+        /// <summary>
+        /// Test appearance setting where the baked texture UUID are library alpha textures.
+        /// </summary>
+        /// <remarks>
+        /// For a mesh avatar, it appears these 'baked textures' are used.  So these should not trigger a request to 
+        /// rebake.
+        /// </remarks>
+        [Test]
+        public void TestSetAppearanceAlphaBakedTextures()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            UUID userId = TestHelpers.ParseTail(0x1);
+            UUID alphaTextureID = new UUID("3a367d1c-bef1-6d43-7595-e88c1e3aadb3");
+
+            // We need an asset cache because otherwise the LocalAssetServiceConnector will short-circuit directly
+            // to the AssetService, which will then store temporary and local assets permanently
+            CoreAssetCache assetCache = new CoreAssetCache();
+            
+            AvatarFactoryModule afm = new AvatarFactoryModule();
+            TestScene scene = new SceneHelpers(assetCache).SetupScene();
+            SceneHelpers.SetupSceneModules(scene, afm);
+            ScenePresence sp = SceneHelpers.AddScenePresence(scene, userId);
+
+            AssetBase libraryAsset;
+            libraryAsset 
+                = new AssetBase(
+                    alphaTextureID, "Default Alpha Layer Texture", (sbyte)AssetType.Texture, userId.ToString());
+            libraryAsset.Data = new byte[] { 2 }; // Not necessary to have a genuine JPEG2000 asset here yet
+            libraryAsset.Temporary = false;
+            libraryAsset.Local = false;
+            scene.AssetService.Store(libraryAsset);
+
+            byte[] visualParams = new byte[AvatarAppearance.VISUALPARAM_COUNT];
+            for (byte i = 0; i < visualParams.Length; i++)
+                visualParams[i] = i;
+
+            Primitive.TextureEntry bakedTextureEntry = new Primitive.TextureEntry(TestHelpers.ParseTail(0x10));
+            uint eyesFaceIndex = (uint)AppearanceManager.BakeTypeToAgentTextureIndex(BakeType.Eyes);
+            Primitive.TextureEntryFace eyesFace = bakedTextureEntry.CreateFace(eyesFaceIndex);
+
+            int rebakeRequestsReceived = 0;
+            ((TestClient)sp.ControllingClient).OnReceivedSendRebakeAvatarTextures += id => rebakeRequestsReceived++;
 
-            // TODO: Check baked texture
-            Assert.AreEqual(visualParams, sp.Appearance.VisualParams);
+            // This is the alpha texture
+            eyesFace.TextureID = alphaTextureID;
+            afm.SetAppearance(sp, bakedTextureEntry, visualParams, null);
+    
+            Assert.That(rebakeRequestsReceived, Is.EqualTo(0));
         }
 
         [Test]
@@ -102,7 +181,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             Primitive.TextureEntryFace eyesFace = bakedTextureEntry.CreateFace(eyesFaceIndex);
             eyesFace.TextureID = eyesTextureId;
 
-            afm.SetAppearance(sp, bakedTextureEntry, visualParams);
+            afm.SetAppearance(sp, bakedTextureEntry, visualParams, null);
             afm.SaveBakedTextures(userId);
 //            Dictionary<BakeType, Primitive.TextureEntryFace> bakedTextures = afm.GetBakedTextureFaces(userId);
 
diff --git a/OpenSim/Region/CoreModules/Avatar/BakedTextures/XBakesModule.cs b/OpenSim/Region/CoreModules/Avatar/BakedTextures/XBakesModule.cs
new file mode 100644
index 0000000..414f06a
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/BakedTextures/XBakesModule.cs
@@ -0,0 +1,200 @@
+/*
+ * 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 Nini.Config;
+using System;
+using System.IO;
+using System.Text;
+using System.Xml;
+using System.Xml.Serialization;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
+using OpenSim.Framework;
+using OpenSim.Framework.ServiceAuth;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Mono.Addins;
+
+namespace OpenSim.Region.CoreModules.Avatar.BakedTextures
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "XBakes.Module")]
+    public class XBakesModule : INonSharedRegionModule, IBakedTextureModule
+    {
+        protected Scene m_Scene;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private UTF8Encoding enc = new UTF8Encoding();
+        private string m_URL = String.Empty;
+        private static XmlSerializer m_serializer = new XmlSerializer(typeof(AssetBase));
+
+        private static IServiceAuth m_Auth;
+
+        public void Initialise(IConfigSource configSource)
+        {
+            IConfig config = configSource.Configs["XBakes"];
+            if (config == null)
+                return;
+
+            m_URL = config.GetString("URL", String.Empty);
+            m_Auth = ServiceAuth.Create(configSource, "XBakes");
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            // m_log.InfoFormat("[XBakes]: Enabled for region {0}", scene.RegionInfo.RegionName);
+            m_Scene = scene;
+
+            scene.RegisterModuleInterface<IBakedTextureModule>(this);
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "XBakes.Module"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public WearableCacheItem[] Get(UUID id)
+        {
+            if (m_URL == String.Empty)
+                return null;
+
+            int size = 0;
+
+            using (RestClient rc = new RestClient(m_URL))
+            {
+                List<WearableCacheItem> ret = new List<WearableCacheItem>();
+                rc.AddResourcePath("bakes");
+                rc.AddResourcePath(id.ToString());
+
+                rc.RequestMethod = "GET";
+
+                try
+                {
+                    Stream s = rc.Request(m_Auth);
+
+                    using (XmlTextReader sr = new XmlTextReader(s))
+                    {
+                        sr.ReadStartElement("BakedAppearance");
+                        while (sr.LocalName == "BakedTexture")
+                        {
+                            string sTextureIndex = sr.GetAttribute("TextureIndex");
+                            int lTextureIndex = Convert.ToInt32(sTextureIndex);
+                            string sCacheId = sr.GetAttribute("CacheId");
+                            UUID lCacheId = UUID.Zero;
+                            if (!(UUID.TryParse(sCacheId, out lCacheId)))
+                            {
+                                // ??  Nothing here
+                            }
+
+                            ++size;
+
+                            sr.ReadStartElement("BakedTexture");
+                            AssetBase a = (AssetBase)m_serializer.Deserialize(sr);
+                            ret.Add(new WearableCacheItem() { CacheId = lCacheId, TextureIndex = (uint)lTextureIndex, TextureAsset = a, TextureID = a.FullID });
+
+                            sr.ReadEndElement();
+                        }
+
+                        m_log.DebugFormat("[XBakes]: read {0} textures for user {1}", ret.Count, id);
+                    }
+
+                    return ret.ToArray();
+                }
+                catch (XmlException)
+                {
+                    return null;
+                }
+            }
+        }
+
+        public void Store(UUID agentId, WearableCacheItem[] data)
+        {
+            if (m_URL == String.Empty)
+                return;
+
+            MemoryStream reqStream;
+
+            using (MemoryStream bakeStream = new MemoryStream())
+            using (XmlTextWriter bakeWriter = new XmlTextWriter(bakeStream, null))
+            {
+                bakeWriter.WriteStartElement(String.Empty, "BakedAppearance", String.Empty);
+
+                for (int i = 0; i < data.Length; i++)
+                {
+                    if (data[i] != null)
+                    {
+                        bakeWriter.WriteStartElement(String.Empty, "BakedTexture", String.Empty);
+                        bakeWriter.WriteAttributeString(String.Empty, "TextureIndex", String.Empty, data[i].TextureIndex.ToString());
+                        bakeWriter.WriteAttributeString(String.Empty, "CacheId", String.Empty, data[i].CacheId.ToString());
+                        if (data[i].TextureAsset != null)
+                            m_serializer.Serialize(bakeWriter, data[i].TextureAsset);
+
+                        bakeWriter.WriteEndElement();
+                    }
+                }
+
+                bakeWriter.WriteEndElement();
+                bakeWriter.Flush();
+
+                reqStream = new MemoryStream(bakeStream.ToArray());
+            }
+
+            RestClient rc = new RestClient(m_URL);
+            rc.AddResourcePath("bakes");
+            rc.AddResourcePath(agentId.ToString());
+
+            rc.RequestMethod = "POST";
+
+            Util.FireAndForget(
+                delegate
+                {
+                    rc.Request(reqStream, m_Auth);
+                    m_log.DebugFormat("[XBakes]: stored {0} textures for user {1}", data.Length, agentId);
+                }, null, "XBakesModule.Store"
+            );
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs b/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
index 6d62ff0..f0b1e67 100644
--- a/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
@@ -32,6 +32,7 @@ using log4net;
 using Nini.Config;
 using Mono.Addins;
 using OpenMetaverse;
+using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
@@ -50,7 +51,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
         private int m_saydistance = 20;
         private int m_shoutdistance = 100;
         private int m_whisperdistance = 10;
-        private List<Scene> m_scenes = new List<Scene>();
 
         internal object m_syncy = new object();
 
@@ -61,18 +61,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
         {
             m_config = config.Configs["Chat"];
 
-            if (null == m_config)
+            if (m_config != null)
             {
-                m_log.Info("[CHAT]: no config found, plugin disabled");
-                m_enabled = false;
-                return;
-            }
-
-            if (!m_config.GetBoolean("enabled", true))
-            {
-                m_log.Info("[CHAT]: plugin disabled by configuration");
-                m_enabled = false;
-                return;
+                if (!m_config.GetBoolean("enabled", true))
+                {
+                    m_log.Info("[CHAT]: plugin disabled by configuration");
+                    m_enabled = false;
+                    return;
+                }
             }
 
             m_whisperdistance = config.Configs["Chat"].GetInt("whisper_distance", m_whisperdistance);
@@ -82,18 +78,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
 
         public virtual void AddRegion(Scene scene)
         {
-            if (!m_enabled) return;
+            if (!m_enabled) 
+                return;
 
-            lock (m_syncy)
-            {
-                if (!m_scenes.Contains(scene))
-                {
-                    m_scenes.Add(scene);
-                    scene.EventManager.OnNewClient += OnNewClient;
-                    scene.EventManager.OnChatFromWorld += OnChatFromWorld;
-                    scene.EventManager.OnChatBroadcast += OnChatBroadcast;
-                }
-            }
+            scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnChatFromWorld += OnChatFromWorld;
+            scene.EventManager.OnChatBroadcast += OnChatBroadcast;
 
             m_log.InfoFormat("[CHAT]: Initialized for {0} w:{1} s:{2} S:{3}", scene.RegionInfo.RegionName,
                              m_whisperdistance, m_saydistance, m_shoutdistance);
@@ -101,22 +91,24 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
 
         public virtual void RegionLoaded(Scene scene)
         {
+            if (!m_enabled)
+                return;
+
+            ISimulatorFeaturesModule featuresModule = scene.RequestModuleInterface<ISimulatorFeaturesModule>();
+
+            if (featuresModule != null)
+                featuresModule.OnSimulatorFeaturesRequest += OnSimulatorFeaturesRequest;
+
         }
 
         public virtual void RemoveRegion(Scene scene)
         {
-            if (!m_enabled) return;
+            if (!m_enabled) 
+                return;
 
-            lock (m_syncy)
-            {
-                if (m_scenes.Contains(scene))
-                {
-                    scene.EventManager.OnNewClient -= OnNewClient;
-                    scene.EventManager.OnChatFromWorld -= OnChatFromWorld;
-                    scene.EventManager.OnChatBroadcast -= OnChatBroadcast;
-                    m_scenes.Remove(scene);
-                }
-            }
+            scene.EventManager.OnNewClient -= OnNewClient;
+            scene.EventManager.OnChatFromWorld -= OnChatFromWorld;
+            scene.EventManager.OnChatBroadcast -= OnChatBroadcast;
         }
         
         public virtual void Close()
@@ -191,23 +183,16 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
             UUID ownerID = UUID.Zero;
             UUID targetID = c.TargetUUID;
             string message = c.Message;
-            IScene scene = c.Scene;
+            Scene scene = (Scene)c.Scene;
             Vector3 fromPos = c.Position;
-            Vector3 regionPos = new Vector3(scene.RegionInfo.RegionLocX * Constants.RegionSize,
-                                            scene.RegionInfo.RegionLocY * Constants.RegionSize, 0);
+            Vector3 regionPos = new Vector3(scene.RegionInfo.WorldLocX, scene.RegionInfo.WorldLocY, 0);
 
             if (c.Channel == DEBUG_CHANNEL) c.Type = ChatTypeEnum.DebugChannel;
 
             switch (sourceType) 
             {
             case ChatSourceType.Agent:
-                if (!(scene is Scene))
-                {
-                    m_log.WarnFormat("[CHAT]: scene {0} is not a Scene object, cannot obtain scene presence for {1}",
-                                     scene.RegionInfo.RegionName, c.Sender.AgentId);
-                    return;
-                }
-                ScenePresence avatar = (scene as Scene).GetScenePresence(c.Sender.AgentId);
+                ScenePresence avatar = scene.GetScenePresence(c.Sender.AgentId);
                 fromPos = avatar.AbsolutePosition;
                 fromName = avatar.Name;
                 fromID = c.Sender.AgentId;
@@ -234,36 +219,33 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
 
             HashSet<UUID> receiverIDs = new HashSet<UUID>();
 
-            foreach (Scene s in m_scenes)
+            if (targetID == UUID.Zero)
             {
-                if (targetID == UUID.Zero)
-                {
-                    // This should use ForEachClient, but clients don't have a position.
-                    // If camera is moved into client, then camera position can be used
-                    s.ForEachRootScenePresence(
-                        delegate(ScenePresence presence)
-                        {
-                            if (TrySendChatMessage(
-                                presence, fromPos, regionPos, fromID, ownerID, fromName, c.Type, message, sourceType, false))
-                                receiverIDs.Add(presence.UUID);
-                        }
-                    );
-                }
-                else
-                {
-                    // This is a send to a specific client eg from llRegionSayTo
-                    // no need to check distance etc, jand send is as say
-                    ScenePresence presence = s.GetScenePresence(targetID);
-                    if (presence != null && !presence.IsChildAgent)
+                // This should use ForEachClient, but clients don't have a position.
+                // If camera is moved into client, then camera position can be used
+                scene.ForEachScenePresence(
+                    delegate(ScenePresence presence)
                     {
                         if (TrySendChatMessage(
-                            presence, fromPos, regionPos, fromID, ownerID, fromName, ChatTypeEnum.Say, message, sourceType, true))
+                            presence, fromPos, regionPos, fromID, ownerID, fromName, c.Type, message, sourceType, false))
                             receiverIDs.Add(presence.UUID);
                     }
+                );
+            }
+            else
+            {
+                // This is a send to a specific client eg from llRegionSayTo
+                // no need to check distance etc, jand send is as say
+                ScenePresence presence = scene.GetScenePresence(targetID);
+                if (presence != null && !presence.IsChildAgent)
+                {
+                    if (TrySendChatMessage(
+                        presence, fromPos, regionPos, fromID, ownerID, fromName, ChatTypeEnum.Say, message, sourceType, true))
+                        receiverIDs.Add(presence.UUID);
                 }
             }
 
-            (scene as Scene).EventManager.TriggerOnChatToClients(
+            scene.EventManager.TriggerOnChatToClients(
                 fromID, receiverIDs, message, c.Type, fromPos, fromName, sourceType, ChatAudibleLevel.Fully);
         }
 
@@ -288,17 +270,20 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
             string fromName = c.From;
             
             UUID fromID = UUID.Zero;
+            UUID ownerID = UUID.Zero;
             ChatSourceType sourceType = ChatSourceType.Object;
             if (null != c.Sender)
             {
                 ScenePresence avatar = (c.Scene as Scene).GetScenePresence(c.Sender.AgentId);
                 fromID = c.Sender.AgentId;
                 fromName = avatar.Name;
+                ownerID = c.Sender.AgentId;
                 sourceType = ChatSourceType.Agent;
             }
             else if (c.SenderUUID != UUID.Zero) 
             {
-                fromID = c.SenderUUID; 
+                fromID = c.SenderUUID;
+                ownerID = ((SceneObjectPart)c.SenderObject).OwnerID;
             }
             
             // m_log.DebugFormat("[CHAT] Broadcast: fromID {0} fromName {1}, cType {2}, sType {3}", fromID, fromName, cType, sourceType);
@@ -316,7 +301,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
                         return;
 
                     client.SendChatMessage(
-                        c.Message, (byte)cType, CenterOfRegion, fromName, fromID, fromID,
+                        c.Message, (byte)cType, CenterOfRegion, fromName, fromID, ownerID,
                         (byte)sourceType, (byte)ChatAudibleLevel.Fully);
 
                     receiverIDs.Add(client.AgentId);
@@ -348,18 +333,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
             UUID fromAgentID, UUID ownerID, string fromName, ChatTypeEnum type,
             string message, ChatSourceType src, bool ignoreDistance)
         {
-            // don't send stuff to child agents
-            if (presence.IsChildAgent) return false;
-
-            Vector3 fromRegionPos = fromPos + regionPos;
-            Vector3 toRegionPos = presence.AbsolutePosition +
-                new Vector3(presence.Scene.RegionInfo.RegionLocX * Constants.RegionSize,
-                            presence.Scene.RegionInfo.RegionLocY * Constants.RegionSize, 0);
-
-            int dis = (int)Util.GetDistanceTo(toRegionPos, fromRegionPos);
+            if (presence.LifecycleState != ScenePresenceState.Running)
+                return false;
 
             if (!ignoreDistance)
             {
+                Vector3 fromRegionPos = fromPos + regionPos;
+                Vector3 toRegionPos = presence.AbsolutePosition +
+                    new Vector3(presence.Scene.RegionInfo.WorldLocX, presence.Scene.RegionInfo.WorldLocY, 0);
+
+                int dis = (int)Util.GetDistanceTo(toRegionPos, fromRegionPos);
+
                 if (type == ChatTypeEnum.Whisper && dis > m_whisperdistance ||
                     type == ChatTypeEnum.Say && dis > m_saydistance ||
                     type == ChatTypeEnum.Shout && dis > m_shoutdistance)
@@ -375,5 +359,33 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
             
             return true;
         }
+
+        #region SimulatorFeaturesRequest
+
+        static OSDInteger m_SayRange, m_WhisperRange, m_ShoutRange;
+
+        private void OnSimulatorFeaturesRequest(UUID agentID, ref OSDMap features)
+        {
+            OSD extras = new OSDMap();
+            if (features.ContainsKey("OpenSimExtras"))
+                extras = features["OpenSimExtras"];
+            else
+                features["OpenSimExtras"] = extras;
+
+            if (m_SayRange == null)
+            {
+                // Do this only once
+                m_SayRange = new OSDInteger(m_saydistance);
+                m_WhisperRange = new OSDInteger(m_whisperdistance);
+                m_ShoutRange = new OSDInteger(m_shoutdistance);
+            }
+
+            ((OSDMap)extras)["say-range"] = m_SayRange;
+            ((OSDMap)extras)["whisper-range"] = m_WhisperRange;
+            ((OSDMap)extras)["shout-range"] = m_ShoutRange;
+
+        }
+
+        #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Chat/Tests/ChatModuleTests.cs b/OpenSim/Region/CoreModules/Avatar/Chat/Tests/ChatModuleTests.cs
new file mode 100644
index 0000000..3018d94
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Chat/Tests/ChatModuleTests.cs
@@ -0,0 +1,285 @@
+/*
+ * 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 log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.CoreModules.Avatar.Chat;
+using OpenSim.Region.CoreModules.Framework;
+using OpenSim.Region.CoreModules.Framework.EntityTransfer;
+using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.CoreModules.Avatar.Chat.Tests
+{
+    [TestFixture]
+    public class ChatModuleTests : OpenSimTestCase
+    {  
+        [TestFixtureSetUp]
+        public void FixtureInit()
+        {
+            // Don't allow tests to be bamboozled by asynchronous events.  Execute everything on the same thread.
+            // We must do this here so that child agent positions are updated in a predictable manner.
+            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;
+        }
+
+        private void SetupNeighbourRegions(TestScene sceneA, TestScene sceneB)
+        {            
+            // XXX: HTTP server is not (and should not be) necessary for this test, though it's absence makes the 
+            // CapabilitiesModule complain when it can't set up HTTP endpoints.
+            //            BaseHttpServer httpServer = new BaseHttpServer(99999);
+            //            MainServer.AddHttpServer(httpServer);
+            //            MainServer.Instance = httpServer;
+
+            // We need entity transfer modules so that when sp2 logs into the east region, the region calls 
+            // EntityTransferModuleto set up a child agent on the west region.
+            // XXX: However, this is not an entity transfer so is misleading.
+            EntityTransferModule etmA = new EntityTransferModule();
+            EntityTransferModule etmB = new EntityTransferModule();
+            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
+
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Chat");
+            IConfig modulesConfig = config.AddConfig("Modules");
+            modulesConfig.Set("EntityTransferModule", etmA.Name);
+            modulesConfig.Set("SimulationServices", lscm.Name);
+
+            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
+            SceneHelpers.SetupSceneModules(sceneA, config, new CapabilitiesModule(), etmA, new ChatModule());           
+            SceneHelpers.SetupSceneModules(sceneB, config, new CapabilitiesModule(), etmB, new ChatModule());
+        }
+
+        /// <summary>
+        /// Tests chat between neighbour regions on the east-west axis
+        /// </summary>
+        /// <remarks>
+        /// Really, this is a combination of a child agent position update test and a chat range test.  These need
+        /// to be separated later on.
+        /// </remarks>
+        [Test]
+        public void TestInterRegionChatDistanceEastWest()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            UUID sp1Uuid = TestHelpers.ParseTail(0x11);
+            UUID sp2Uuid = TestHelpers.ParseTail(0x12);
+
+            Vector3 sp1Position = new Vector3(6, 128, 20);
+            Vector3 sp2Position = new Vector3(250, 128, 20);
+
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneWest = sh.SetupScene("sceneWest", TestHelpers.ParseTail(0x1), 1000, 1000);            
+            TestScene sceneEast = sh.SetupScene("sceneEast", TestHelpers.ParseTail(0x2), 1001, 1000);            
+
+            SetupNeighbourRegions(sceneWest, sceneEast);
+
+            ScenePresence sp1 = SceneHelpers.AddScenePresence(sceneEast, sp1Uuid);
+            TestClient sp1Client = (TestClient)sp1.ControllingClient;
+
+            // If we don't set agents to flying, test will go wrong as they instantly fall to z = 0.
+            // TODO: May need to create special complete no-op test physics module rather than basic physics, since
+            // physics is irrelevant to this test.
+            sp1.Flying = true;
+
+            // When sp1 logs in to sceneEast, it sets up a child agent in sceneWest and informs the sp2 client to 
+            // make the connection.  For this test, will simplify this chain by making the connection directly.
+            ScenePresence sp1Child = SceneHelpers.AddChildScenePresence(sceneWest, sp1Uuid);
+            TestClient sp1ChildClient = (TestClient)sp1Child.ControllingClient;
+
+            sp1.AbsolutePosition = sp1Position;                
+
+            ScenePresence sp2 = SceneHelpers.AddScenePresence(sceneWest, sp2Uuid);
+            TestClient sp2Client = (TestClient)sp2.ControllingClient;
+            sp2.Flying = true;
+
+            ScenePresence sp2Child = SceneHelpers.AddChildScenePresence(sceneEast, sp2Uuid);
+            TestClient sp2ChildClient = (TestClient)sp2Child.ControllingClient;
+
+            sp2.AbsolutePosition = sp2Position;           
+
+            // We must update the scenes in order to make the root new root agents trigger position updates in their
+            // children.
+            sceneWest.Update(1);
+            sceneEast.Update(1);
+
+            // Check child positions are correct.
+            Assert.AreEqual(
+                new Vector3(sp1Position.X + sceneEast.RegionInfo.RegionSizeX, sp1Position.Y, sp1Position.Z), 
+                sp1ChildClient.SceneAgent.AbsolutePosition);
+
+            Assert.AreEqual(
+                new Vector3(sp2Position.X - sceneWest.RegionInfo.RegionSizeX, sp2Position.Y, sp2Position.Z), 
+                sp2ChildClient.SceneAgent.AbsolutePosition);
+
+            string receivedSp1ChatMessage = "";
+            string receivedSp2ChatMessage = "";
+
+            sp1ChildClient.OnReceivedChatMessage 
+                += (message, type, fromPos, fromName, fromAgentID, ownerID, source, audible) => receivedSp1ChatMessage = message;
+            sp2ChildClient.OnReceivedChatMessage 
+                += (message, type, fromPos, fromName, fromAgentID, ownerID, source, audible) => receivedSp2ChatMessage = message;
+
+            TestUserInRange(sp1Client, "ello darling", ref receivedSp2ChatMessage);
+            TestUserInRange(sp2Client, "fantastic cats", ref receivedSp1ChatMessage);
+
+            sp1Position = new Vector3(30, 128, 20);
+            sp1.AbsolutePosition = sp1Position;
+            sceneEast.Update(1);
+
+            // Check child position is correct.
+            Assert.AreEqual(
+                new Vector3(sp1Position.X + sceneEast.RegionInfo.RegionSizeX, sp1Position.Y, sp1Position.Z), 
+                sp1ChildClient.SceneAgent.AbsolutePosition);
+
+            TestUserOutOfRange(sp1Client, "beef", ref receivedSp2ChatMessage);
+            TestUserOutOfRange(sp2Client, "lentils", ref receivedSp1ChatMessage);
+        }
+
+        /// <summary>
+        /// Tests chat between neighbour regions on the north-south axis
+        /// </summary>
+        /// <remarks>
+        /// Really, this is a combination of a child agent position update test and a chat range test.  These need
+        /// to be separated later on.
+        /// </remarks>
+        [Test]
+        public void TestInterRegionChatDistanceNorthSouth()
+        {
+            TestHelpers.InMethod();
+            //            TestHelpers.EnableLogging();
+
+            UUID sp1Uuid = TestHelpers.ParseTail(0x11);
+            UUID sp2Uuid = TestHelpers.ParseTail(0x12);
+
+            Vector3 sp1Position = new Vector3(128, 250, 20);
+            Vector3 sp2Position = new Vector3(128, 6, 20);
+
+            SceneHelpers sh = new SceneHelpers();
+            TestScene sceneNorth = sh.SetupScene("sceneNorth", TestHelpers.ParseTail(0x1), 1000, 1000);            
+            TestScene sceneSouth = sh.SetupScene("sceneSouth", TestHelpers.ParseTail(0x2), 1000, 1001);            
+
+            SetupNeighbourRegions(sceneNorth, sceneSouth);
+
+            ScenePresence sp1 = SceneHelpers.AddScenePresence(sceneNorth, sp1Uuid);
+            TestClient sp1Client = (TestClient)sp1.ControllingClient;
+
+            // If we don't set agents to flying, test will go wrong as they instantly fall to z = 0.
+            // TODO: May need to create special complete no-op test physics module rather than basic physics, since
+            // physics is irrelevant to this test.
+            sp1.Flying = true;
+
+            // When sp1 logs in to sceneEast, it sets up a child agent in sceneNorth and informs the sp2 client to 
+            // make the connection.  For this test, will simplify this chain by making the connection directly.
+            ScenePresence sp1Child = SceneHelpers.AddChildScenePresence(sceneSouth, sp1Uuid);
+            TestClient sp1ChildClient = (TestClient)sp1Child.ControllingClient;
+
+            sp1.AbsolutePosition = sp1Position;                
+
+            ScenePresence sp2 = SceneHelpers.AddScenePresence(sceneSouth, sp2Uuid);
+            TestClient sp2Client = (TestClient)sp2.ControllingClient;
+            sp2.Flying = true;
+
+            ScenePresence sp2Child = SceneHelpers.AddChildScenePresence(sceneNorth, sp2Uuid);
+            TestClient sp2ChildClient = (TestClient)sp2Child.ControllingClient;
+
+            sp2.AbsolutePosition = sp2Position;           
+
+            // We must update the scenes in order to make the root new root agents trigger position updates in their
+            // children.
+            sceneNorth.Update(1);
+            sceneSouth.Update(1);
+
+            // Check child positions are correct.
+            Assert.AreEqual(
+                new Vector3(sp1Position.X, sp1Position.Y - sceneNorth.RegionInfo.RegionSizeY, sp1Position.Z), 
+                sp1ChildClient.SceneAgent.AbsolutePosition);
+
+            Assert.AreEqual(
+                new Vector3(sp2Position.X, sp2Position.Y + sceneSouth.RegionInfo.RegionSizeY, sp2Position.Z), 
+                sp2ChildClient.SceneAgent.AbsolutePosition);
+
+            string receivedSp1ChatMessage = "";
+            string receivedSp2ChatMessage = "";
+
+            sp1ChildClient.OnReceivedChatMessage 
+                += (message, type, fromPos, fromName, fromAgentID, ownerID, source, audible) => receivedSp1ChatMessage = message;
+            sp2ChildClient.OnReceivedChatMessage 
+                += (message, type, fromPos, fromName, fromAgentID, ownerID, source, audible) => receivedSp2ChatMessage = message;
+
+            TestUserInRange(sp1Client, "ello darling", ref receivedSp2ChatMessage);
+            TestUserInRange(sp2Client, "fantastic cats", ref receivedSp1ChatMessage);
+
+            sp1Position = new Vector3(30, 128, 20);
+            sp1.AbsolutePosition = sp1Position;
+            sceneNorth.Update(1);
+
+            // Check child position is correct.
+            Assert.AreEqual(
+                new Vector3(sp1Position.X, sp1Position.Y - sceneNorth.RegionInfo.RegionSizeY, sp1Position.Z), 
+                sp1ChildClient.SceneAgent.AbsolutePosition);
+
+            TestUserOutOfRange(sp1Client, "beef", ref receivedSp2ChatMessage);
+            TestUserOutOfRange(sp2Client, "lentils", ref receivedSp1ChatMessage);
+        }
+    
+        private void TestUserInRange(TestClient speakClient, string testMessage, ref string receivedMessage)
+        {
+            receivedMessage = "";
+
+            speakClient.Chat(0, ChatTypeEnum.Say, testMessage);
+
+            Assert.AreEqual(testMessage, receivedMessage);
+        }
+
+        private void TestUserOutOfRange(TestClient speakClient, string testMessage, ref string receivedMessage)
+        {
+            receivedMessage = "";
+
+            speakClient.Chat(0, ChatTypeEnum.Say, testMessage);
+
+            Assert.AreNotEqual(testMessage, receivedMessage);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs b/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
index 343cdb5..fc23b72 100644
--- a/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
@@ -31,6 +31,7 @@ using Nini.Config;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
 using OpenMetaverse;
 
 using Mono.Addins;
@@ -182,6 +183,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Combat.CombatModule
             try
             {
                 ILandObject obj = avatar.Scene.LandChannel.GetLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
+
+                if (obj == null)
+                    return;
+
                 if ((obj.LandData.Flags & (uint)ParcelFlags.AllowDamage) != 0
                     || avatar.Scene.RegionInfo.RegionSettings.AllowDamage)
                 {
diff --git a/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs b/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs
index d26907b..a896897 100644
--- a/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs
@@ -133,13 +133,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Dialog
                 UUID objectID, UUID ownerID, string message, UUID textureID,
                 int ch, string[] buttonlabels)
         {
-            UserAccount account = m_scene.UserAccountService.GetUserAccount(
-                    m_scene.RegionInfo.ScopeID, ownerID);
-            string ownerFirstName, ownerLastName;
-            if (account != null)
+            string username = m_scene.UserManagementModule.GetUserName(ownerID);
+            string ownerFirstName, ownerLastName = String.Empty;
+            if (!String.IsNullOrEmpty(username))
             {
-                ownerFirstName = account.FirstName;
-                ownerLastName = account.LastName;
+                string[] parts = username.Split(' ');
+                ownerFirstName = parts[0];
+                if (parts.Length > 1)
+                    ownerLastName = username.Split(' ')[1];
             }
             else
             {
@@ -170,17 +171,16 @@ namespace OpenSim.Region.CoreModules.Avatar.Dialog
         }
 
         public void SendTextBoxToUser(UUID avatarid, string message,
-                int chatChannel, string name, UUID objectid, UUID ownerid)
+                int chatChannel, string name, UUID objectid, UUID ownerID)
         {
-            UserAccount account = m_scene.UserAccountService.GetUserAccount(
-                    m_scene.RegionInfo.ScopeID, ownerid);
-            string ownerFirstName, ownerLastName;
-            UUID ownerID = UUID.Zero;
-            if (account != null)
+            string username = m_scene.UserManagementModule.GetUserName(ownerID);
+            string ownerFirstName, ownerLastName = String.Empty;
+            if (!String.IsNullOrEmpty(username))
             {
-                ownerFirstName = account.FirstName;
-                ownerLastName = account.LastName;
-                ownerID = account.PrincipalID;
+                string[] parts = username.Split(' ');
+                ownerFirstName = parts[0];
+                if (parts.Length > 1)
+                    ownerLastName = username.Split(' ')[1];
             }
             else
             {
diff --git a/OpenSim/Region/CoreModules/Avatar/Friends/CallingCardModule.cs b/OpenSim/Region/CoreModules/Avatar/Friends/CallingCardModule.cs
index 5ec0ea9..eb23e83 100644
--- a/OpenSim/Region/CoreModules/Avatar/Friends/CallingCardModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Friends/CallingCardModule.cs
@@ -36,6 +36,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
 using Mono.Addins;
+using PermissionMask = OpenSim.Framework.PermissionMask;
 
 namespace OpenSim.Region.CoreModules.Avatar.Friends
 {
@@ -180,7 +181,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             if (folderID == UUID.Zero)
             {
                 InventoryFolderBase folder = inv.GetFolderForType(userID,
-                        AssetType.CallingCard);
+                        FolderType.CallingCard);
 
                 if (folder == null) // Nowhere to put it
                     return UUID.Zero;
@@ -236,7 +237,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             IInventoryService invService = m_Scenes[0].InventoryService;
 
             InventoryFolderBase trashFolder =
-                    invService.GetFolderForType(client.AgentId, AssetType.TrashFolder);
+                    invService.GetFolderForType(client.AgentId, FolderType.Trash);
 
             InventoryItemBase item = new InventoryItemBase(transactionID, client.AgentId);
             item = invService.GetItem(item);
diff --git a/OpenSim/Region/CoreModules/Avatar/Friends/FriendsModule.cs b/OpenSim/Region/CoreModules/Avatar/Friends/FriendsModule.cs
index 8056030..08e7dd2 100644
--- a/OpenSim/Region/CoreModules/Avatar/Friends/FriendsModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Friends/FriendsModule.cs
@@ -38,7 +38,6 @@ using OpenMetaverse;
 using Mono.Addins;
 using OpenSim.Framework;
 using OpenSim.Framework.Servers.HttpServer;
-using OpenSim.Framework.Communications;
 using OpenSim.Framework.Servers;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
@@ -94,6 +93,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
         protected Dictionary<UUID, UserFriendData> m_Friends = new Dictionary<UUID, UserFriendData>();
 
         /// <summary>
+        /// Maintain a record of clients that need to notify about their online status. This only
+        /// needs to be done on login.  Subsequent online/offline friend changes are sent by a different mechanism.
+        /// </summary>
+        protected HashSet<UUID> m_NeedsToNotifyStatus = new HashSet<UUID>();
+
+        /// <summary>
         /// Maintain a record of viewers that need to be sent notifications for friends that are online.  This only
         /// needs to be done on login.  Subsequent online/offline friend changes are sent by a different mechanism.
         /// </summary>
@@ -324,6 +329,15 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
         private void OnMakeRootAgent(ScenePresence sp)
         {
             RecacheFriends(sp.ControllingClient);
+
+            lock (m_NeedsToNotifyStatus)
+            {
+                if (m_NeedsToNotifyStatus.Remove(sp.UUID))
+                {
+                    // Inform the friends that this user is online. This can only be done once the client is a Root Agent.
+                    StatusChange(sp.UUID, true);
+                }
+            }
         }
 
         private void OnClientLogin(IClientAPI client)
@@ -331,8 +345,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             UUID agentID = client.AgentId;
 
             //m_log.DebugFormat("[XXX]: OnClientLogin!");
-            // Inform the friends that this user is online
-            StatusChange(agentID, true);
+
+            // Register that we need to send this user's status to friends. This can only be done
+            // once the client becomes a Root Agent, because as part of sending out the presence
+            // we also get back the presence of the HG friends, and we need to send that to the
+            // client, but that can only be done when the client is a Root Agent.
+            lock (m_NeedsToNotifyStatus)
+                m_NeedsToNotifyStatus.Add(agentID);
 
             // Register that we need to send the list of online friends to this user
             lock (m_NeedsListOfOnlineFriends)
@@ -371,7 +390,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             foreach (string fid in outstanding)
             {
                 UUID fromAgentID;
-                string firstname = "Unknown", lastname = "User";
+                string firstname = "Unknown", lastname = "UserFMSFOIN";
                 if (!GetAgentInfo(client.Scene.RegionInfo.ScopeID, fid, out fromAgentID, out firstname, out lastname))
                 {
                     m_log.DebugFormat("[FRIENDS MODULE]: skipping malformed friend {0}", fid);
@@ -397,7 +416,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         protected virtual bool GetAgentInfo(UUID scopeID, string fid, out UUID agentID, out string first, out string last)
         {
-            first = "Unknown"; last = "User";
+            first = "Unknown"; last = "UserFMGAI";
             if (!UUID.TryParse(fid, out agentID))
                 return false;
 
@@ -491,13 +510,15 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
                         // Notify about this user status
                         StatusNotify(friendList, agentID, online);
-                    }
+                    }, null, "FriendsModule.StatusChange"
                 );
             }
         }
 
         protected virtual void StatusNotify(List<FriendInfo> friendList, UUID userID, bool online)
         {
+            //m_log.DebugFormat("[FRIENDS]: Entering StatusNotify for {0}", userID);
+
             List<string> friendStringIds = friendList.ConvertAll<string>(friend => friend.Friend);
             List<string> remoteFriendStringIds = new List<string>();
             foreach (string friendStringId in friendStringIds)
@@ -523,12 +544,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             foreach (PresenceInfo friendSession in friendSessions)
             {
                 // let's guard against sessions-gone-bad
-                if (friendSession.RegionID != UUID.Zero)
+                if (friendSession != null && friendSession.RegionID != UUID.Zero)
                 {
+                    //m_log.DebugFormat("[FRIENDS]: Get region {0}", friendSession.RegionID);
                     GridRegion region = GridService.GetRegionByUUID(m_Scenes[0].RegionInfo.ScopeID, friendSession.RegionID);
-                    //m_log.DebugFormat("[FRIENDS]: Remote Notify to region {0}", region.RegionName);
-                    m_FriendsSimConnector.StatusNotify(region, userID, friendSession.UserID, online);
+                    if (region != null)
+                    {
+                        m_FriendsSimConnector.StatusNotify(region, userID, friendSession.UserID, online);
+                    }
                 }
+                //else
+                //    m_log.DebugFormat("[FRIENDS]: friend session is null or the region is UUID.Zero");
             }
         }
 
@@ -685,7 +711,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             //
 
             // Try local
-            if (LocalFriendshipTerminated(exfriendID))
+            if (LocalFriendshipTerminated(client.AgentId, exfriendID))
                 return;
 
             PresenceInfo[] friendSessions = PresenceService.GetAgents(new string[] { exfriendID.ToString() });
@@ -827,13 +853,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             return false;
         }
 
-        public bool LocalFriendshipTerminated(UUID exfriendID)
+        public bool LocalFriendshipTerminated(UUID userID, UUID exfriendID)
         {
             IClientAPI friendClient = LocateClientObject(exfriendID);
             if (friendClient != null)
             {
                 // the friend in this sim as root agent
-                friendClient.SendTerminateFriend(exfriendID);
+                friendClient.SendTerminateFriend(userID);
                 // update local cache
                 RecacheFriends(friendClient);
                 // we're done
diff --git a/OpenSim/Region/CoreModules/Avatar/Friends/FriendsRequestHandler.cs b/OpenSim/Region/CoreModules/Avatar/Friends/FriendsRequestHandler.cs
index 637beef..13512a2 100644
--- a/OpenSim/Region/CoreModules/Avatar/Friends/FriendsRequestHandler.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Friends/FriendsRequestHandler.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -42,19 +42,27 @@ using log4net;
 
 namespace OpenSim.Region.CoreModules.Avatar.Friends
 {
-    public class FriendsRequestHandler : BaseStreamHandler
+    public class FriendsRequestHandler : BaseStreamHandlerBasicDOSProtector
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private FriendsModule m_FriendsModule;
 
         public FriendsRequestHandler(FriendsModule fmodule)
-                : base("POST", "/friends")
+                : base("POST", "/friends", new BasicDosProtectorOptions()
+                                          {
+                                              AllowXForwardedFor = true,
+                                              ForgetTimeSpan = TimeSpan.FromMinutes(2),
+                                              MaxRequestsInTimeframe = 20,
+                                              ReportingName = "FRIENDSDOSPROTECTOR",
+                                              RequestTimeSpan = TimeSpan.FromSeconds(5),
+                                              ThrottledAction = BasicDOSProtector.ThrottleAction.DoThrottledMethod
+                                          })
         {
             m_FriendsModule = fmodule;
         }
 
-        public override byte[] Handle(
+        protected override byte[] ProcessRequest(
             string path, Stream requestData, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
         {
             StreamReader sr = new StreamReader(requestData);
@@ -193,7 +201,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             if (!UUID.TryParse(request["ToID"].ToString(), out toID))
                 return FailureResult();
 
-            if (m_FriendsModule.LocalFriendshipTerminated(toID))
+            if (m_FriendsModule.LocalFriendshipTerminated(fromID, toID))
                 return SuccessResult();
 
             return FailureResult();
@@ -281,18 +289,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
             rootElement.AppendChild(result);
 
-            return DocToBytes(doc);
-        }
-
-        private byte[] DocToBytes(XmlDocument doc)
-        {
-            MemoryStream ms = new MemoryStream();
-            XmlTextWriter xw = new XmlTextWriter(ms, null);
-            xw.Formatting = Formatting.Indented;
-            doc.WriteTo(xw);
-            xw.Flush();
-
-            return ms.ToArray();
+            return Util.DocToBytes(doc);
         }
 
         #endregion
diff --git a/OpenSim/Region/CoreModules/Avatar/Friends/HGFriendsModule.cs b/OpenSim/Region/CoreModules/Avatar/Friends/HGFriendsModule.cs
index bf5c0bb..27b7376 100644
--- a/OpenSim/Region/CoreModules/Avatar/Friends/HGFriendsModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Friends/HGFriendsModule.cs
@@ -183,6 +183,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                                 if (Util.ParseUniversalUserIdentifier(finfo.Friend, out id, out url, out first, out last, out tmp))
                                 {
                                     IUserManagement uMan = m_Scenes[0].RequestModuleInterface<IUserManagement>();
+                                    m_log.DebugFormat("[HGFRIENDS MODULE]: caching {0}", finfo.Friend);
                                     uMan.AddUser(id, url + ";" + first + " " + last);
                                 }
                             }
@@ -238,6 +239,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                     fList.Add(s.Substring(0, 36));
             }
 
+            // FIXME: also query the presence status of friends in other grids (like in HGStatusNotifier.Notify())
+
             PresenceInfo[] presence = PresenceService.GetAgents(fList.ToArray());
             foreach (PresenceInfo pi in presence)
             {
@@ -251,7 +254,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         protected override void StatusNotify(List<FriendInfo> friendList, UUID userID, bool online)
         {
-//            m_log.DebugFormat("[HGFRIENDS MODULE]: Entering StatusNotify for {0}", userID);
+            //m_log.DebugFormat("[HGFRIENDS MODULE]: Entering StatusNotify for {0}", userID);
 
             // First, let's divide the friends on a per-domain basis
             Dictionary<string, List<FriendInfo>> friendsPerDomain = new Dictionary<string, List<FriendInfo>>();
@@ -293,7 +296,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         protected override bool GetAgentInfo(UUID scopeID, string fid, out UUID agentID, out string first, out string last)
         {
-            first = "Unknown"; last = "User";
+            first = "Unknown"; last = "UserHGGAI";
             if (base.GetAgentInfo(scopeID, fid, out agentID, out first, out last))
                 return true;
 
@@ -349,7 +352,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
         public override FriendInfo[] GetFriendsFromService(IClientAPI client)
         {
-//            m_log.DebugFormat("[HGFRIENDS MODULE]: Entering GetFriendsFromService for {0}", client.Name);
+            //            m_log.DebugFormat("[HGFRIENDS MODULE]: Entering GetFriendsFromService for {0}", client.Name);
             Boolean agentIsLocal = true;
             if (UserManagementModule != null)
                 agentIsLocal = UserManagementModule.IsLocalGridUser(client.AgentId);
@@ -362,13 +365,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
             AgentCircuitData agentClientCircuit = ((Scene)(client.Scene)).AuthenticateHandler.GetAgentCircuitData(client.CircuitCode);
             if (agentClientCircuit != null)
             {
-                //[XXX] string agentUUI = Util.ProduceUserUniversalIdentifier(agentClientCircuit);
-
+                // Note that this is calling a different interface than base; this one calls with a string param!
                 finfos = FriendsService.GetFriends(client.AgentId.ToString());
                 m_log.DebugFormat("[HGFRIENDS MODULE]: Fetched {0} local friends for visitor {1}", finfos.Length, client.AgentId.ToString());
             }
 
-//            m_log.DebugFormat("[HGFRIENDS MODULE]: Exiting GetFriendsFromService for {0}", client.Name);
+            //            m_log.DebugFormat("[HGFRIENDS MODULE]: Exiting GetFriendsFromService for {0}", client.Name);
 
             return finfos;
         }
@@ -658,7 +660,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                     FriendsService.Delete(friendUUI, agentID.ToString());
 
                     // notify the exfriend's service
-                    Util.FireAndForget(delegate { Delete(exfriendID, agentID, friendUUI); });
+                    Util.FireAndForget(
+                        delegate { Delete(exfriendID, agentID, friendUUI); }, null, "HGFriendsModule.DeleteFriendshipForeignFriend");
 
                     m_log.DebugFormat("[HGFRIENDS MODULE]: {0} terminated {1}", agentID, friendUUI);
                     return true;
@@ -676,7 +679,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
                     FriendsService.Delete(agentUUI, exfriendID.ToString());
 
                     // notify the agent's service?
-                    Util.FireAndForget(delegate { Delete(agentID, exfriendID, agentUUI); });
+                    Util.FireAndForget(
+                        delegate { Delete(agentID, exfriendID, agentUUI); }, null, "HGFriendsModule.DeleteFriendshipLocalFriend");
 
                     m_log.DebugFormat("[HGFRIENDS MODULE]: {0} terminated {1}", agentUUI, exfriendID);
                     return true;
diff --git a/OpenSim/Region/CoreModules/Avatar/Friends/Tests/FriendModuleTests.cs b/OpenSim/Region/CoreModules/Avatar/Friends/Tests/FriendModuleTests.cs
index 961117e..e6fd54e 100644
--- a/OpenSim/Region/CoreModules/Avatar/Friends/Tests/FriendModuleTests.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Friends/Tests/FriendModuleTests.cs
@@ -35,7 +35,6 @@ using OpenSim.Framework;
 using OpenSim.Region.CoreModules.Avatar.Friends;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Region.CoreModules.Avatar.Friends.Tests
 {
diff --git a/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs b/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs
index 5a7446f..3b6d970 100644
--- a/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Gods/GodsModule.cs
@@ -26,20 +26,37 @@
  */
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.IO;
+using System.Reflection;
+using System.Web;
+using System.Xml;
+using log4net;
+using Mono.Addins;
 using Nini.Config;
 using OpenMetaverse;
+using OpenMetaverse.Messages.Linden;
+using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Interfaces;
-
-using Mono.Addins;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OSDArray = OpenMetaverse.StructuredData.OSDArray;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
 
 namespace OpenSim.Region.CoreModules.Avatar.Gods
 {
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "GodsModule")]
     public class GodsModule : INonSharedRegionModule, IGodsModule
     {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         /// <summary>Special UUID for actions that apply to all agents</summary>
         private static readonly UUID ALL_AGENTS = new UUID("44e87126-e794-4ded-05b3-7c42da3d5cdb");
 
@@ -65,6 +82,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
             m_scene = scene;
             m_scene.RegisterModuleInterface<IGodsModule>(this);
             m_scene.EventManager.OnNewClient += SubscribeToClientEvents;
+            m_scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+            scene.EventManager.OnIncomingInstantMessage +=
+                    OnIncomingInstantMessage;
         }
 
         public void RemoveRegion(Scene scene)
@@ -98,6 +118,47 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
             client.OnRequestGodlikePowers -= RequestGodlikePowers;
         }
         
+        private void OnRegisterCaps(UUID agentID, Caps caps)
+        {
+            string uri = "/CAPS/" + UUID.Random();
+
+            caps.RegisterHandler(
+                "UntrustedSimulatorMessage", 
+                new RestStreamHandler("POST", uri, HandleUntrustedSimulatorMessage, "UntrustedSimulatorMessage", null));
+        }
+
+        private string HandleUntrustedSimulatorMessage(string request,
+                string path, string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+            OSDMap osd = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+
+            string message = osd["message"].AsString();
+
+            if (message == "GodKickUser")
+            {
+                OSDMap body = (OSDMap)osd["body"];
+                OSDArray userInfo = (OSDArray)body["UserInfo"];
+                OSDMap userData = (OSDMap)userInfo[0];
+
+                UUID agentID = userData["AgentID"].AsUUID();
+                UUID godID = userData["GodID"].AsUUID();
+                UUID godSessionID = userData["GodSessionID"].AsUUID();
+                uint kickFlags = userData["KickFlags"].AsUInteger();
+                string reason = userData["Reason"].AsString();
+                ScenePresence god = m_scene.GetScenePresence(godID);
+                if (god == null || god.ControllingClient.SessionId != godSessionID)
+                    return String.Empty;
+
+                KickUser(godID, godSessionID, agentID, kickFlags, Util.StringToBytes1024(reason));
+            }
+            else
+            {
+                m_log.ErrorFormat("[GOD]: Unhandled UntrustedSimulatorMessage: {0}", message);
+            }
+            return String.Empty;
+        }
+
         public void RequestGodlikePowers(
             UUID agentID, UUID sessionID, UUID token, bool godLike, IClientAPI controllingClient)
         {
@@ -146,76 +207,85 @@ namespace OpenSim.Region.CoreModules.Avatar.Gods
         /// <param name="reason">The message to send to the user after it's been turned into a field</param>
         public void KickUser(UUID godID, UUID sessionID, UUID agentID, uint kickflags, byte[] reason)
         {
-            UUID kickUserID = ALL_AGENTS;
-            
+            if (!m_scene.Permissions.IsGod(godID))
+                return;
+
             ScenePresence sp = m_scene.GetScenePresence(agentID);
 
-            if (sp != null || agentID == kickUserID)
+            if (sp == null && agentID != ALL_AGENTS)
             {
-                if (m_scene.Permissions.IsGod(godID))
+                IMessageTransferModule transferModule =
+                        m_scene.RequestModuleInterface<IMessageTransferModule>();
+                if (transferModule != null)
                 {
-                    if (kickflags == 0)
-                    {
-                        if (agentID == kickUserID)
-                        {
-                            string reasonStr = Utils.BytesToString(reason);
-
-                            m_scene.ForEachClient(
-                                delegate(IClientAPI controller)
-                                {
-                                    if (controller.AgentId != godID)
-                                        controller.Kick(reasonStr);
-                                }
-                            );
-
-                            // This is a bit crude. It seems the client will be null before it actually stops the thread
-                            // The thread will kill itself eventually :/
-                            // Is there another way to make sure *all* clients get this 'inter region' message?
-                            m_scene.ForEachRootClient(
-                                delegate(IClientAPI client)
-                                {
-                                    if (client.AgentId != godID)
-                                    {
-                                        client.Close();
-                                    }
-                                }
-                            );
-                        }
-                        else
-                        {
-                            m_scene.SceneGraph.removeUserCount(!sp.IsChildAgent);
+                    m_log.DebugFormat("[GODS]: Sending nonlocal kill for agent {0}", agentID);
+                    transferModule.SendInstantMessage(new GridInstantMessage(
+                            m_scene, godID, "God", agentID, (byte)250, false,
+                            Utils.BytesToString(reason), UUID.Zero, true,
+                            new Vector3(), new byte[] {(byte)kickflags}, true),
+                            delegate(bool success) {} );
+                }
+                return;
+            }
 
-                            sp.ControllingClient.Kick(Utils.BytesToString(reason));
-                            sp.ControllingClient.Close();
-                        }
-                    }
-                    
-                    if (kickflags == 1)
-                    {
-                        sp.AllowMovement = false;
-                        if (DialogModule != null)
-                        {
-                            DialogModule.SendAlertToUser(agentID, Utils.BytesToString(reason));
-                            DialogModule.SendAlertToUser(godID, "User Frozen");
-                        }
-                    }
-                    
-                    if (kickflags == 2)
-                    {
-                        sp.AllowMovement = true;
-                        if (DialogModule != null)
-                        {
-                            DialogModule.SendAlertToUser(agentID, Utils.BytesToString(reason));
-                            DialogModule.SendAlertToUser(godID, "User Unfrozen");
-                        }
-                    }
+            switch (kickflags)
+            {
+            case 0:
+                if (sp != null)
+                {
+                    KickPresence(sp, Utils.BytesToString(reason));
                 }
-                else
+                else if (agentID == ALL_AGENTS)
                 {
-                    if (DialogModule != null)
-                        DialogModule.SendAlertToUser(godID, "Kick request denied");
+                    m_scene.ForEachRootScenePresence(
+                            delegate(ScenePresence p)
+                            {
+                                if (p.UUID != godID && (!m_scene.Permissions.IsGod(p.UUID)))
+                                    KickPresence(p, Utils.BytesToString(reason));
+                            }
+                    );
                 }
+                break;
+            case 1:
+                if (sp != null)
+                {
+                    sp.AllowMovement = false;
+                    m_dialogModule.SendAlertToUser(agentID, Utils.BytesToString(reason));
+                    m_dialogModule.SendAlertToUser(godID, "User Frozen");
+                }
+                break;
+            case 2:
+                if (sp != null)
+                {
+                    sp.AllowMovement = true;
+                    m_dialogModule.SendAlertToUser(agentID, Utils.BytesToString(reason));
+                    m_dialogModule.SendAlertToUser(godID, "User Unfrozen");
+                }
+                break;
+            default:
+                break;
+            }
+        }
+
+        private void KickPresence(ScenePresence sp, string reason)
+        {
+            if (sp.IsChildAgent)
+                return;
+            sp.ControllingClient.Kick(reason);
+            sp.Scene.CloseAgent(sp.UUID, true); 
+        }
+
+        private void OnIncomingInstantMessage(GridInstantMessage msg)
+        {
+            if (msg.dialog == (uint)250) // Nonlocal kick
+            {
+                UUID agentID = new UUID(msg.toAgentID);
+                string reason = msg.message;
+                UUID godID = new UUID(msg.fromAgentID);
+                uint kickMode = (uint)msg.binaryBucket[0];
+
+                KickUser(godID, UUID.Zero, agentID, kickMode, Util.StringToBytes1024(reason));
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/HGMessageTransferModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/HGMessageTransferModule.cs
index 7bf19c2..a1b918a 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/HGMessageTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/HGMessageTransferModule.cs
@@ -210,10 +210,10 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                     success = m_IMService.OutgoingInstantMessage(im, url, foreigner);
 
                 if (!success && !foreigner)
-                    HandleUndeliveredMessage(im, result);
+                    HandleUndeliverableMessage(im, result);
                 else
                     result(success);
-            });
+            }, null, "HGMessageTransferModule.SendInstantMessage");
 
             return;
         }
@@ -246,7 +246,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
             return successful;
         }
 
-        protected void HandleUndeliveredMessage(GridInstantMessage im, MessageResultNotification result)
+        public void HandleUndeliverableMessage(GridInstantMessage im, MessageResultNotification result)
         {
             UndeliveredMessage handlerUndeliveredMessage = OnUndeliveredMessage;
 
@@ -282,7 +282,17 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                         string uasURL = circuit.ServiceURLs["HomeURI"].ToString();
                         m_log.DebugFormat("[HG MESSAGE TRANSFER]: getting UUI of user {0} from {1}", toAgent, uasURL);
                         UserAgentServiceConnector uasConn = new UserAgentServiceConnector(uasURL);
-                        return uasConn.GetUUI(fromAgent, toAgent);
+
+                        string agentUUI = string.Empty;
+                        try
+                        {
+                            agentUUI = uasConn.GetUUI(fromAgent, toAgent);
+                        }
+                        catch (Exception e) {
+                            m_log.Debug("[HG MESSAGE TRANSFER]: GetUUI call failed ", e);
+                        }
+
+                        return agentUUI;
                     }
                 }
             }
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs
index fa935cd..2462ff8 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs
@@ -181,7 +181,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
             SendGridInstantMessageViaXMLRPC(im, result);
         }
 
-        private void HandleUndeliveredMessage(GridInstantMessage im, MessageResultNotification result)
+        public void HandleUndeliverableMessage(GridInstantMessage im, MessageResultNotification result)
         {
             UndeliveredMessage handlerUndeliveredMessage = OnUndeliveredMessage;
 
@@ -372,7 +372,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                     gim.fromAgentName = fromAgentName;
                     gim.fromGroup = fromGroup;
                     gim.imSessionID = imSessionID.Guid;
-                    gim.RegionID = UUID.Zero.Guid; // RegionID.Guid;
+                    gim.RegionID = RegionID.Guid;
                     gim.timestamp = timestamp;
                     gim.toAgentID = toAgentID.Guid;
                     gim.message = message;
@@ -428,7 +428,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         /// <summary>
         /// delegate for sending a grid instant message asynchronously
         /// </summary>
-        public delegate void GridInstantMessageDelegate(GridInstantMessage im, MessageResultNotification result, UUID prevRegionID);
+        public delegate void GridInstantMessageDelegate(GridInstantMessage im, MessageResultNotification result);
 
         protected virtual void GridInstantMessageCompleted(IAsyncResult iar)
         {
@@ -442,138 +442,87 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         {
             GridInstantMessageDelegate d = SendGridInstantMessageViaXMLRPCAsync;
 
-            d.BeginInvoke(im, result, UUID.Zero, GridInstantMessageCompleted, d);
+            d.BeginInvoke(im, result, GridInstantMessageCompleted, d);
         }
 
         /// <summary>
-        /// Recursive SendGridInstantMessage over XMLRPC method.
-        /// This is called from within a dedicated thread.
-        /// The first time this is called, prevRegionHandle will be 0 Subsequent times this is called from 
-        /// itself, prevRegionHandle will be the last region handle that we tried to send.
-        /// If the handles are the same, we look up the user's location using the grid.
-        /// If the handles are still the same, we end.  The send failed.
+        /// Internal SendGridInstantMessage over XMLRPC method.
         /// </summary>
-        /// <param name="prevRegionHandle">
-        /// Pass in 0 the first time this method is called.  It will be called recursively with the last 
-        /// regionhandle tried
-        /// </param>
-        protected virtual void SendGridInstantMessageViaXMLRPCAsync(GridInstantMessage im, MessageResultNotification result, UUID prevRegionID)
+        /// <remarks>
+        /// This is called from within a dedicated thread.
+        /// </remarks>
+        private void SendGridInstantMessageViaXMLRPCAsync(GridInstantMessage im, MessageResultNotification result)
         {
             UUID toAgentID = new UUID(im.toAgentID);
-
-            PresenceInfo upd = null;
-
-            bool lookupAgent = false;
+            UUID regionID;
+            bool needToLookupAgent;
 
             lock (m_UserRegionMap)
+                needToLookupAgent = !m_UserRegionMap.TryGetValue(toAgentID, out regionID);
+
+            while (true)
             {
-                if (m_UserRegionMap.ContainsKey(toAgentID))
+                if (needToLookupAgent)
                 {
-                    upd = new PresenceInfo();
-                    upd.RegionID = m_UserRegionMap[toAgentID];
+                    PresenceInfo[] presences = PresenceService.GetAgents(new string[] { toAgentID.ToString() }); 
 
-                    // We need to compare the current regionhandle with the previous region handle
-                    // or the recursive loop will never end because it will never try to lookup the agent again
-                    if (prevRegionID == upd.RegionID)
-                    {
-                        lookupAgent = true;
-                    }
-                }
-                else
-                {
-                    lookupAgent = true;
-                }
-            }
-            
+                    UUID foundRegionID = UUID.Zero;
 
-            // Are we needing to look-up an agent?
-            if (lookupAgent)
-            {
-                // Non-cached user agent lookup.
-                PresenceInfo[] presences = PresenceService.GetAgents(new string[] { toAgentID.ToString() }); 
-                if (presences != null && presences.Length > 0)
-                {
-                    foreach (PresenceInfo p in presences)
+                    if (presences != null)
                     {
-                        if (p.RegionID != UUID.Zero)
+                        foreach (PresenceInfo p in presences)
                         {
-                            upd = p;
-                            break;
+                            if (p.RegionID != UUID.Zero)
+                            {
+                                foundRegionID = p.RegionID;
+                                break;
+                            }
                         }
                     }
-                }
 
-                if (upd != null)
-                {
-                    // check if we've tried this before..
-                    // This is one way to end the recursive loop
-                    //
-                    if (upd.RegionID == prevRegionID)
-                    {
-                        // m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
-                        HandleUndeliveredMessage(im, result);
-                        return;
-                    }
+                    // If not found or the found region is the same as the last lookup, then message is undeliverable
+                    if (foundRegionID == UUID.Zero || foundRegionID == regionID)
+                        break;
+                    else
+                        regionID = foundRegionID;
                 }
-                else
+
+                GridRegion reginfo = m_Scenes[0].GridService.GetRegionByUUID(m_Scenes[0].RegionInfo.ScopeID, regionID);
+                if (reginfo == null)
                 {
-                    // m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
-                    HandleUndeliveredMessage(im, result);
-                    return;
+                    m_log.WarnFormat("[GRID INSTANT MESSAGE]: Unable to find region {0}", regionID);
+                    break;
                 }
-            }
 
-            if (upd != null)
-            {
-                GridRegion reginfo = m_Scenes[0].GridService.GetRegionByUUID(m_Scenes[0].RegionInfo.ScopeID,
-                    upd.RegionID);
-                if (reginfo != null)
+                // Try to send the message to the agent via the retrieved region.
+                Hashtable msgdata = ConvertGridInstantMessageToXMLRPC(im);
+                msgdata["region_handle"] = 0;
+                bool imresult = doIMSending(reginfo, msgdata);
+
+                // If the message delivery was successful, then cache the entry.
+                if (imresult)
                 {
-                    Hashtable msgdata = ConvertGridInstantMessageToXMLRPC(im);
-                    // Not actually used anymore, left in for compatibility
-                    // Remove at next interface change
-                    //
-                    msgdata["region_handle"] = 0;
-                    bool imresult = doIMSending(reginfo, msgdata);
-                    if (imresult)
-                    {
-                        // IM delivery successful, so store the Agent's location in our local cache.
-                        lock (m_UserRegionMap)
-                        {
-                            if (m_UserRegionMap.ContainsKey(toAgentID))
-                            {
-                                m_UserRegionMap[toAgentID] = upd.RegionID;
-                            }
-                            else
-                            {
-                                m_UserRegionMap.Add(toAgentID, upd.RegionID);
-                            }
-                        }
-                        result(true);
-                    }
-                    else
+                    lock (m_UserRegionMap)
                     {
-                        // try again, but lookup user this time.
-                        // Warning, this must call the Async version
-                        // of this method or we'll be making thousands of threads
-                        // The version within the spawned thread is SendGridInstantMessageViaXMLRPCAsync
-                        // The version that spawns the thread is SendGridInstantMessageViaXMLRPC
-
-                        // This is recursive!!!!!
-                        SendGridInstantMessageViaXMLRPCAsync(im, result,
-                                upd.RegionID);
+                        m_UserRegionMap[toAgentID] = regionID;
                     }
+                    result(true);
+                    return;
                 }
-                else
-                {
-                    m_log.WarnFormat("[GRID INSTANT MESSAGE]: Unable to find region {0}", upd.RegionID);
-                    HandleUndeliveredMessage(im, result);
-                }
-            }
-            else
-            {
-                HandleUndeliveredMessage(im, result);
+
+                // If we reach this point in the first iteration of the while, then we may have unsuccessfully tried
+                // to use a locally cached region ID.  All subsequent attempts need to lookup agent details from
+                // the presence service.
+                needToLookupAgent = true;
             }
+
+            // If we reached this point then the message was not deliverable.  Remove the bad cache entry and 
+            // signal the delivery failure.
+            lock (m_UserRegionMap)
+                m_UserRegionMap.Remove(toAgentID);
+
+            // m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
+            HandleUndeliverableMessage(im, result);
         }
 
         /// <summary>
@@ -584,7 +533,6 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         /// <returns>Bool if the message was successfully delivered at the other side.</returns>
         protected virtual bool doIMSending(GridRegion reginfo, Hashtable xmlrpcdata)
         {
-
             ArrayList SendParams = new ArrayList();
             SendParams.Add(xmlrpcdata);
             XmlRpcRequest GridReq = new XmlRpcRequest("grid_instant_message", SendParams);
@@ -672,7 +620,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
             gim["position_x"] = msg.Position.X.ToString();
             gim["position_y"] = msg.Position.Y.ToString();
             gim["position_z"] = msg.Position.Z.ToString();
-            gim["region_id"] = msg.RegionID.ToString();
+            gim["region_id"] = new UUID(msg.RegionID).ToString();
             gim["binary_bucket"] = Convert.ToBase64String(msg.binaryBucket,Base64FormattingOptions.None);
             return gim;
         }
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/MuteListModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/MuteListModule.cs
index 7ce2813..315d372 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/MuteListModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/MuteListModule.cs
@@ -32,7 +32,6 @@ using Nini.Config;
 using Mono.Addins;
 using OpenMetaverse;
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Client;
 using OpenSim.Region.Framework.Interfaces;
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs
index 7d763fa..9cdb1c2 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs
@@ -32,7 +32,6 @@ using Mono.Addins;
 using Nini.Config;
 using OpenMetaverse;
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Client;
 using OpenSim.Region.Framework.Interfaces;
@@ -182,7 +181,10 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                         "POST", m_RestURL + "/RetrieveMessages/", client.AgentId);
 
                 if (msglist == null)
+                {
                     m_log.WarnFormat("[OFFLINE MESSAGING]: WARNING null message list.");
+                    return;
+                }
 
                 foreach (GridInstantMessage im in msglist)
                 {
@@ -223,12 +225,8 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                     return;
             }
 
-            Scene scene = FindScene(new UUID(im.fromAgentID));
-            if (scene == null)
-                scene = m_SceneList[0];
-
             bool success = SynchronousRestObjectRequester.MakeRequest<GridInstantMessage, bool>(
-                    "POST", m_RestURL+"/SaveMessage/", im);
+                    "POST", m_RestURL+"/SaveMessage/", im, 10000);
 
             if (im.dialog == (byte)InstantMessageDialog.MessageFromAgent)
             {
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs
index 4c678c2..c2440d8 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs
@@ -49,8 +49,10 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         private static readonly ILog m_log = LogManager.GetLogger(
                 MethodBase.GetCurrentMethod().DeclaringType);
 
+#pragma warning disable 0067
         public event PresenceChange OnPresenceChange;
         public event BulkPresenceData OnBulkPresenceData;
+#pragma warning restore 0067
 
         protected List<Scene> m_Scenes = new List<Scene>();
 
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
index ecbd07f..4a06fd1 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
@@ -61,16 +61,22 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 
         private UserAccount m_userInfo;
         private string m_invPath;
+
+        /// <value>
+        /// ID of this request
+        /// </value>
+        protected UUID m_id;
         
         /// <summary>
         /// Do we want to merge this load with existing inventory?
         /// </summary>
         protected bool m_merge;
 
-        /// <value>
-        /// We only use this to request modules
-        /// </value>
-        protected Scene m_scene;
+        protected IInventoryService m_InventoryService;
+        protected IAssetService m_AssetService;
+        protected IUserAccountService m_UserAccountService;
+
+        private InventoryArchiverModule m_module;
 
         /// <value>
         /// The stream from which the inventory archive will be loaded.
@@ -115,12 +121,29 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// Record the creator id that should be associated with an asset.  This is used to adjust asset creator ids
         /// after OSP resolution (since OSP creators are only stored in the item
         /// </summary>
-        protected Dictionary<UUID, UUID> m_creatorIdForAssetId = new Dictionary<UUID, UUID>();        
+        protected Dictionary<UUID, UUID> m_creatorIdForAssetId = new Dictionary<UUID, UUID>();
+
+        public InventoryArchiveReadRequest(
+            IInventoryService inv, IAssetService assets, IUserAccountService uacc, UserAccount userInfo, string invPath, string loadPath, bool merge)
+            : this(UUID.Zero, null,
+                            inv,
+                assets,
+                uacc,
+                userInfo,
+                invPath,
+                loadPath,
+                merge)
+        {
+        }
 
         public InventoryArchiveReadRequest(
-            Scene scene, UserAccount userInfo, string invPath, string loadPath, bool merge)
+            UUID id, InventoryArchiverModule module, IInventoryService inv, IAssetService assets, IUserAccountService uacc, UserAccount userInfo, string invPath, string loadPath, bool merge)
             : this(
-                scene,
+                id,
+                module,
+                inv,
+                assets,
+                uacc,
                 userInfo,
                 invPath,
                 new GZipStream(ArchiveHelpers.GetStream(loadPath), CompressionMode.Decompress),
@@ -129,13 +152,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         }
 
         public InventoryArchiveReadRequest(
-            Scene scene, UserAccount userInfo, string invPath, Stream loadStream, bool merge)
+            UUID id, InventoryArchiverModule module, IInventoryService inv, IAssetService assets, IUserAccountService uacc, UserAccount userInfo, string invPath, Stream loadStream, bool merge)
         {
-            m_scene = scene;
+            m_id = id;
+            m_InventoryService = inv;
+            m_AssetService = assets;
+            m_UserAccountService = uacc;
             m_merge = merge;
             m_userInfo = userInfo;
             m_invPath = invPath;
             m_loadStream = loadStream;
+            m_module = module;
             
             // FIXME: Do not perform this check since older versions of OpenSim do save the control file after other things
             // (I thought they weren't).  We will need to bump the version number and perform this check on all 
@@ -158,11 +185,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         {
             try
             {
+                Exception reportedException = null;
+
                 string filePath = "ERROR";
                
                 List<InventoryFolderBase> folderCandidates
-                    = InventoryArchiveUtils.FindFolderByPath(
-                        m_scene.InventoryService, m_userInfo.PrincipalID, m_invPath);
+                    = InventoryArchiveUtils.FindFoldersByPath(
+                        m_InventoryService, m_userInfo.PrincipalID, m_invPath);
     
                 if (folderCandidates.Count == 0)
                 {
@@ -194,14 +223,25 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 }
                 
                 archive.Close();
-                
+
                 m_log.DebugFormat(
                     "[INVENTORY ARCHIVER]: Successfully loaded {0} assets with {1} failures", 
                     m_successfulAssetRestores, m_failedAssetRestores);
-                m_log.InfoFormat("[INVENTORY ARCHIVER]: Successfully loaded {0} items", m_successfulItemRestores);
+
+                //Alicia: When this is called by LibraryModule or Tests, m_module will be null as event is not required
+                if(m_module != null)
+                    m_module.TriggerInventoryArchiveLoaded(m_id, true, m_userInfo, m_invPath, m_loadStream, reportedException, m_successfulItemRestores);
                 
                 return m_loadedNodes;
             }
+            catch(Exception Ex)
+            {
+                // Trigger saved event with failed result and exception data
+                if (m_module != null)
+                    m_module.TriggerInventoryArchiveLoaded(m_id, false, m_userInfo, m_invPath, m_loadStream, Ex, 0);
+
+                return m_loadedNodes;
+            }
             finally
             {
                 m_loadStream.Close();
@@ -296,8 +336,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                         // iar name and try to find that instead.
                         string plainPath = ArchiveConstants.ExtractPlainPathFromIarPath(archivePath);
                         List<InventoryFolderBase> folderCandidates
-                            = InventoryArchiveUtils.FindFolderByPath(
-                                m_scene.InventoryService, m_userInfo.PrincipalID, plainPath);
+                            = InventoryArchiveUtils.FindFoldersByPath(
+                                m_InventoryService, m_userInfo.PrincipalID, plainPath);
             
                         if (folderCandidates.Count != 0)
                         {
@@ -372,15 +412,11 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 newFolderName = InventoryArchiveUtils.UnescapeArchivePath(newFolderName);
                 UUID newFolderId = UUID.Random();
 
-                // Asset type has to be Unknown here rather than Folder, otherwise the created folder can't be
-                // deleted once the client has relogged.
-                // The root folder appears to be labelled AssetType.Folder (shows up as "Category" in the client)
-                // even though there is a AssetType.RootCategory
                 destFolder 
                     = new InventoryFolderBase(
-                        newFolderId, newFolderName, m_userInfo.PrincipalID, 
-                        (short)AssetType.Unknown, destFolder.ID, 1);
-                m_scene.InventoryService.AddFolder(destFolder);
+                        newFolderId, newFolderName, m_userInfo.PrincipalID,
+                        (short)FolderType.None, destFolder.ID, 1);
+                m_InventoryService.AddFolder(destFolder);
 
                 // Record that we have now created this folder
                 iarPathExisting += rawDirsToCreate[i] + "/";
@@ -406,7 +442,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             // Don't use the item ID that's in the file
             item.ID = UUID.Random();
 
-            UUID ospResolvedId = OspResolver.ResolveOspa(item.CreatorId, m_scene.UserAccountService);
+            UUID ospResolvedId = OspResolver.ResolveOspa(item.CreatorId, m_UserAccountService);
             if (UUID.Zero != ospResolvedId) // The user exists in this grid
             {
 //                m_log.DebugFormat("[INVENTORY ARCHIVER]: Found creator {0} via OSPA resolution", ospResolvedId);
@@ -418,7 +454,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 item.CreatorId = ospResolvedId.ToString();
                 item.CreatorData = string.Empty;
             }
-            else if (item.CreatorData == null || item.CreatorData == String.Empty)
+            else if (string.IsNullOrEmpty(item.CreatorData))
             {
                 item.CreatorId = m_userInfo.PrincipalID.ToString();
 //                item.CreatorIdAsUuid = new UUID(item.CreatorId);
@@ -436,7 +472,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             // relying on native tar tools.
             m_creatorIdForAssetId[item.AssetID] = item.CreatorIdAsUuid;
 
-            m_scene.AddInventoryItem(item);
+            if (!m_InventoryService.AddItem(item))
+                m_log.WarnFormat("[INVENTORY ARCHIVER]: Unable to save item {0} in folder {1}", item.Name, item.Folder);
         
             return item;
         }
@@ -479,52 +516,24 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 {
                     if (m_creatorIdForAssetId.ContainsKey(assetId))
                     {
-                        string xmlData = Utils.BytesToString(data);
-                        List<SceneObjectGroup> sceneObjects = new List<SceneObjectGroup>();
+                        data = SceneObjectSerializer.ModifySerializedObject(assetId, data,
+                            sog => {
+                                bool modified = false;
+                                
+                                foreach (SceneObjectPart sop in sog.Parts)
+                                {
+                                    if (string.IsNullOrEmpty(sop.CreatorData))
+                                    {
+                                        sop.CreatorID = m_creatorIdForAssetId[assetId];
+                                        modified = true;
+                                    }
+                                }
+                                
+                                return modified;
+                            });
                         
-                        CoalescedSceneObjects coa = null;
-                        if (CoalescedSceneObjectsSerializer.TryFromXml(xmlData, out coa))
-                        {
-//                            m_log.DebugFormat(
-//                                "[INVENTORY ARCHIVER]: Loaded coalescence {0} has {1} objects", assetId, coa.Count);
-
-                            if (coa.Objects.Count == 0)
-                            {
-                                m_log.WarnFormat(
-                                    "[INVENTORY ARCHIVE READ REQUEST]: Aborting load of coalesced object from asset {0} as it has zero loaded components", 
-                                    assetId);
-                                return false;
-                            }
-                            
-                            sceneObjects.AddRange(coa.Objects);
-                        }
-                        else
-                        {
-                            SceneObjectGroup deserializedObject = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
-
-                            if (deserializedObject != null)
-                            {
-                                sceneObjects.Add(deserializedObject);
-                            }
-                            else
-                            {
-                                m_log.WarnFormat(
-                                    "[INVENTORY ARCHIVE READ REQUEST]: Aborting load of object from asset {0} as deserialization failed", 
-                                    assetId);
-
-                                return false;
-                            }
-                        }
-                        
-                        foreach (SceneObjectGroup sog in sceneObjects)
-                            foreach (SceneObjectPart sop in sog.Parts)
-                                if (sop.CreatorData == null || sop.CreatorData == "")
-                                    sop.CreatorID = m_creatorIdForAssetId[assetId];
-
-                        if (coa != null)
-                            data = Utils.StringToBytes(CoalescedSceneObjectsSerializer.ToXml(coa));
-                        else
-                            data = Utils.StringToBytes(SceneObjectSerializer.ToOriginalXmlFormat(sceneObjects[0]));
+                        if (data == null)
+                            return false;
                     }
                 }
 
@@ -533,7 +542,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 AssetBase asset = new AssetBase(assetId, "From IAR", assetType, UUID.Zero.ToString());
                 asset.Data = data;
 
-                m_scene.AssetService.Store(asset);
+                m_AssetService.Store(asset);
 
                 return true;
             }
@@ -546,7 +555,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 return false;
             }
         }
-        
+
         /// <summary>
         /// Load control file
         /// </summary>
@@ -652,4 +661,4 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             m_assetsLoaded = true;            
         }                 
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveUtils.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveUtils.cs
index 0d90a15..dbaf2aa 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveUtils.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveUtils.cs
@@ -52,13 +52,82 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// <summary>
         /// Find a folder given a PATH_DELIMITER delimited path starting from a user's root folder
         /// </summary>
+        /// <remarks>
+        /// This method does not handle paths that contain multiple delimitors
+        ///
+        /// FIXME: We have no way of distinguishing folders with the same path
         ///
+        /// FIXME: Delimitors which occur in names themselves are not currently escapable.
+        /// </remarks>
+        /// <param name="inventoryService">
+        /// Inventory service to query
+        /// </param>
+        /// <param name="userId">
+        /// User id to search
+        /// </param>
+        /// <param name="path">
+        /// The path to the required folder.
+        /// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned.
+        /// </param>
+        /// <returns>The folder found.  Please note that if there are multiple folders with the same name then an 
+        /// unspecified one will be returned.  If no such folder eixsts then null is returned</returns>
+        public static InventoryFolderBase FindFolderByPath(
+            IInventoryService inventoryService, UUID userId, string path)
+        {
+            List<InventoryFolderBase> folders = FindFoldersByPath(inventoryService, userId, path);
+
+            if (folders.Count == 0)
+                return null;
+            else
+                return folders[0];
+        }
+
+        /// <summary>
+        /// Find a folder given a PATH_DELIMITER delimited path starting from a given folder
+        /// </summary>
+        /// <remarks>
         /// This method does not handle paths that contain multiple delimitors
         ///
         /// FIXME: We have no way of distinguishing folders with the same path
         ///
         /// FIXME: Delimitors which occur in names themselves are not currently escapable.
+        /// </remarks>
+        /// <param name="inventoryService">
+        /// Inventory service to query
+        /// </param>
+        /// <param name="startFolder">
+        /// The folder from which the path starts
+        /// </param>
+        /// <param name="path">
+        /// The path to the required folder.
+        /// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned.
+        /// </param>
+        /// <returns>The folder found.  Please note that if there are multiple folders with the same name then an 
+        /// unspecified one will be returned.  If no such folder eixsts then null is returned</returns>
+        public static InventoryFolderBase FindFolderByPath(
+            IInventoryService inventoryService, InventoryFolderBase startFolder, string path)
+        {
+            if (null == startFolder)
+                return null;
+
+            List<InventoryFolderBase> folders = FindFoldersByPath(inventoryService, startFolder, path);
+
+            if (folders.Count == 0)
+                return null;
+            else
+                return folders[0];
+        }
+
+        /// <summary>
+        /// Find a set of folders given a PATH_DELIMITER delimited path starting from a user's root folder
+        /// </summary>
+        /// <remarks>
+        /// This method does not handle paths that contain multiple delimitors
+        ///
+        /// FIXME: We have no way of distinguishing folders with the same path
         ///
+        /// FIXME: Delimitors which occur in names themselves are not currently escapable.
+        /// </remarks>
         /// <param name="inventoryService">
         /// Inventory service to query
         /// </param>
@@ -70,7 +139,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned.
         /// </param>
         /// <returns>An empty list if the folder is not found, otherwise a list of all folders that match the name</returns>
-        public static List<InventoryFolderBase> FindFolderByPath(
+        public static List<InventoryFolderBase> FindFoldersByPath(
             IInventoryService inventoryService, UUID userId, string path)
         {
             InventoryFolderBase rootFolder = inventoryService.GetRootFolder(userId);
@@ -78,19 +147,19 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             if (null == rootFolder)
                 return new List<InventoryFolderBase>();
 
-            return FindFolderByPath(inventoryService, rootFolder, path);
+            return FindFoldersByPath(inventoryService, rootFolder, path);
         }
         
         /// <summary>
-        /// Find a folder given a PATH_DELIMITER delimited path starting from this folder
+        /// Find a set of folders given a PATH_DELIMITER delimited path starting from this folder
         /// </summary>
-        ///
+        /// <remarks>
         /// This method does not handle paths that contain multiple delimitors
         ///
         /// FIXME: We have no way of distinguishing folders with the same path.
         ///
         /// FIXME: Delimitors which occur in names themselves are not currently escapable.
-        ///
+        /// </remarks>
         /// <param name="inventoryService">
         /// Inventory service to query
         /// </param>
@@ -102,7 +171,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned.
         /// </param>
         /// <returns>An empty list if the folder is not found, otherwise a list of all folders that match the name</returns>
-        public static List<InventoryFolderBase> FindFolderByPath(
+        public static List<InventoryFolderBase> FindFoldersByPath(
             IInventoryService inventoryService, InventoryFolderBase startFolder, string path)
         {
             List<InventoryFolderBase> foundFolders = new List<InventoryFolderBase>();
@@ -133,12 +202,15 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             
             InventoryCollection contents = inventoryService.GetFolderContent(startFolder.Owner, startFolder.ID);
 
+//            m_log.DebugFormat(
+//                "Found {0} folders in {1} for {2}", contents.Folders.Count, startFolder.Name, startFolder.Owner);
+
             foreach (InventoryFolderBase folder in contents.Folders)
             {
                 if (folder.Name == components[0])
                 {
                     if (components.Length > 1)
-                        foundFolders.AddRange(FindFolderByPath(inventoryService, folder, components[1]));
+                        foundFolders.AddRange(FindFoldersByPath(inventoryService, folder, components[1]));
                     else
                         foundFolders.Add(folder);
                 }
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs
index d0e88f6..f002ad7 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs
@@ -34,6 +34,7 @@ using System.Xml;
 using log4net;
 using OpenMetaverse;
 using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Serialization;
 using OpenSim.Framework.Serialization.External;
 using OpenSim.Region.CoreModules.World.Archiver;
@@ -42,6 +43,8 @@ using OpenSim.Services.Interfaces;
 using Ionic.Zlib;
 using GZipStream = Ionic.Zlib.GZipStream;
 using CompressionMode = Ionic.Zlib.CompressionMode;
+using CompressionLevel = Ionic.Zlib.CompressionLevel;
+using PermissionMask = OpenSim.Framework.PermissionMask;
 
 namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 {
@@ -54,6 +57,22 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// </summary>
         public bool SaveAssets { get; set; }
 
+        /// <summary>
+        /// Determines which items will be included in the archive, according to their permissions.
+        /// Default is null, meaning no permission checks.
+        /// </summary>
+        public string FilterContent { get; set; }
+
+        /// <summary>
+        /// Counter for inventory items saved to archive for passing to compltion event
+        /// </summary>
+        public int CountItems { get; set; }
+
+        /// <summary>
+        /// Counter for inventory items skipped due to permission filter option for passing to compltion event
+        /// </summary>
+        public int CountFiltered { get; set; }
+
         /// <value>
         /// Used to select all inventory nodes in a folder but not the folder itself
         /// </value>
@@ -73,12 +92,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// <value>
         /// ID of this request
         /// </value>
-        protected Guid m_id;
-
-        /// <value>
-        /// Used to collect the uuids of the assets that we need to save into the archive
-        /// </value>
-        protected Dictionary<UUID, AssetType> m_assetUuids = new Dictionary<UUID, AssetType>();
+        protected UUID m_id;
 
         /// <value>
         /// Used to collect the uuids of the users that we need to save into the archive
@@ -94,7 +108,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// Constructor
         /// </summary>
         public InventoryArchiveWriteRequest(
-            Guid id, InventoryArchiverModule module, Scene scene,
+            UUID id, InventoryArchiverModule module, Scene scene,
             UserAccount userInfo, string invPath, string savePath)
             : this(
                 id,
@@ -110,7 +124,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// Constructor
         /// </summary>
         public InventoryArchiveWriteRequest(
-            Guid id, InventoryArchiverModule module, Scene scene,
+            UUID id, InventoryArchiverModule module, Scene scene,
             UserAccount userInfo, string invPath, Stream saveStream)
         {
             m_id = id;
@@ -122,9 +136,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             m_assetGatherer = new UuidGatherer(m_scene.AssetService);
 
             SaveAssets = true;
+            FilterContent = null;
         }
 
-        protected void ReceivedAllAssets(ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids)
+        protected void ReceivedAllAssets(ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids, bool timedOut)
         {
             Exception reportedException = null;
             bool succeeded = true;
@@ -143,8 +158,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 m_saveStream.Close();
             }
 
+            if (timedOut)
+            {
+                succeeded = false;
+                reportedException = new Exception("Loading assets timed out");
+            }
+
             m_module.TriggerInventoryArchiveSaved(
-                m_id, succeeded, m_userInfo, m_invPath, m_saveStream, reportedException);
+                m_id, succeeded, m_userInfo, m_invPath, m_saveStream, reportedException, CountItems, CountFiltered);
         }
 
         protected void SaveInvItem(InventoryItemBase inventoryItem, string path, Dictionary<string, object> options, IUserAccountService userAccountService)
@@ -160,10 +181,26 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                             "[INVENTORY ARCHIVER]: Skipping inventory item {0} {1} at {2}",
                             inventoryItem.Name, inventoryItem.ID, path);
                     }
+
+                    CountFiltered++;
+
                     return;
                 }
             }
 
+            // Check For Permissions Filter Flags
+            if (!CanUserArchiveObject(m_userInfo.PrincipalID, inventoryItem))
+            {
+                m_log.InfoFormat(
+                            "[INVENTORY ARCHIVER]: Insufficient permissions, skipping inventory item {0} {1} at {2}",
+                            inventoryItem.Name, inventoryItem.ID, path);
+
+                // Count Items Excluded
+                CountFiltered++;
+
+                return;
+            }
+
             if (options.ContainsKey("verbose"))
                 m_log.InfoFormat(
                     "[INVENTORY ARCHIVER]: Saving item {0} {1} (asset UUID {2})",
@@ -179,9 +216,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 
             AssetType itemAssetType = (AssetType)inventoryItem.AssetType;
 
+            // Count inventory items (different to asset count)
+            CountItems++;
+
             // Don't chase down link asset items as they actually point to their target item IDs rather than an asset
             if (SaveAssets && itemAssetType != AssetType.Link && itemAssetType != AssetType.LinkFolder)
-                m_assetGatherer.GatherAssetUuids(inventoryItem.AssetID, (AssetType)inventoryItem.AssetType, m_assetUuids);
+                m_assetGatherer.AddForInspection(inventoryItem.AssetID);
         }
 
         /// <summary>
@@ -237,6 +277,35 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         }
 
         /// <summary>
+        /// Checks whether the user has permission to export an inventory item to an IAR.
+        /// </summary>
+        /// <param name="UserID">The user</param>
+        /// <param name="InvItem">The inventory item</param>
+        /// <returns>Whether the user is allowed to export the object to an IAR</returns>
+        private bool CanUserArchiveObject(UUID UserID, InventoryItemBase InvItem)
+        {
+            if (FilterContent == null)
+                return true;// Default To Allow Export
+
+            bool permitted = true;
+
+            bool canCopy = (InvItem.CurrentPermissions & (uint)PermissionMask.Copy) != 0;
+            bool canTransfer = (InvItem.CurrentPermissions & (uint)PermissionMask.Transfer) != 0;
+            bool canMod = (InvItem.CurrentPermissions & (uint)PermissionMask.Modify) != 0;
+
+            if (FilterContent.Contains("C") && !canCopy)
+                permitted = false;
+
+            if (FilterContent.Contains("T") && !canTransfer)
+                permitted = false;
+
+            if (FilterContent.Contains("M") && !canMod)
+                permitted = false;
+
+            return permitted;
+        }
+
+        /// <summary>
         /// Execute the inventory write request
         /// </summary>
         public void Execute(Dictionary<string, object> options, IUserAccountService userAccountService)
@@ -244,6 +313,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             if (options.ContainsKey("noassets") && (bool)options["noassets"])
                 SaveAssets = false;
 
+            // Set Permission filter if flag is set
+            if (options.ContainsKey("checkPermissions"))
+            {
+                Object temp;
+                if (options.TryGetValue("checkPermissions", out temp))
+                    FilterContent = temp.ToString().ToUpper();
+            }
+
             try
             {
                 InventoryFolderBase inventoryFolder = null;
@@ -266,6 +343,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                     saveFolderContentsOnly = true;
                     maxComponentIndex--;
                 }
+                else if (maxComponentIndex == -1)
+                {
+                    // If the user has just specified "/", then don't save the root "My Inventory" folder.  This is
+                    // more intuitive then requiring the user to specify "/*" for this.
+                    saveFolderContentsOnly = true;
+                }
 
                 m_invPath = String.Empty;
                 for (int i = 0; i <= maxComponentIndex; i++)
@@ -283,7 +366,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                 {
                     m_invPath = m_invPath.Remove(m_invPath.LastIndexOf(InventoryFolderImpl.PATH_DELIMITER));
                     List<InventoryFolderBase> candidateFolders
-                        = InventoryArchiveUtils.FindFolderByPath(m_scene.InventoryService, rootFolder, m_invPath);
+                        = InventoryArchiveUtils.FindFoldersByPath(m_scene.InventoryService, rootFolder, m_invPath);
                     if (candidateFolders.Count > 0)
                         inventoryFolder = candidateFolders[0];
                 }
@@ -297,7 +380,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                     // We couldn't find the path indicated
                     string errorMessage = string.Format("Aborted save.  Could not find inventory path {0}", m_invPath);
                     Exception e = new InventoryArchiverException(errorMessage);
-                    m_module.TriggerInventoryArchiveSaved(m_id, false, m_userInfo, m_invPath, m_saveStream, e);
+                    m_module.TriggerInventoryArchiveSaved(m_id, false, m_userInfo, m_invPath, m_saveStream, e, 0, 0);
                     throw e;
                 }
 
@@ -335,22 +418,25 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 
                 if (SaveAssets)
                 {
-                    m_log.DebugFormat("[INVENTORY ARCHIVER]: Saving {0} assets for items", m_assetUuids.Count);
+                    m_assetGatherer.GatherAll();
+
+                    m_log.DebugFormat(
+                        "[INVENTORY ARCHIVER]: Saving {0} assets for items", m_assetGatherer.GatheredUuids.Count);
 
                     AssetsRequest ar
                         = new AssetsRequest(
                             new AssetsArchiver(m_archiveWriter),
-                            m_assetUuids, m_scene.AssetService,
+                            m_assetGatherer.GatheredUuids, m_scene.AssetService,
                             m_scene.UserAccountService, m_scene.RegionInfo.ScopeID,
                             options, ReceivedAllAssets);
 
-                    Util.FireAndForget(o => ar.Execute());
+                    WorkManager.RunInThread(o => ar.Execute(), null, string.Format("AssetsRequest ({0})", m_scene.Name));
                 }
                 else
                 {
                     m_log.DebugFormat("[INVENTORY ARCHIVER]: Not saving assets since --noassets was specified");
 
-                    ReceivedAllAssets(new List<UUID>(), new List<UUID>());
+                    ReceivedAllAssets(new List<UUID>(), new List<UUID>(), false);
                 }
             }
             catch (Exception)
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs
index 849449b..8847414 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs
@@ -34,7 +34,6 @@ using NDesk.Options;
 using Nini.Config;
 using OpenMetaverse;
 using OpenSim.Framework;
-using OpenSim.Framework.Communications;
 using OpenSim.Framework.Console;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
@@ -57,6 +56,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 //        public bool DisablePresenceChecks { get; set; }
 
         public event InventoryArchiveSaved OnInventoryArchiveSaved;
+        public event InventoryArchiveLoaded OnInventoryArchiveLoaded;
 
         /// <summary>
         /// The file to load and save inventory if no filename has been specified
@@ -64,9 +64,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         protected const string DEFAULT_INV_BACKUP_FILENAME = "user-inventory.iar";
 
         /// <value>
-        /// Pending save completions initiated from the console
+        /// Pending save and load completions initiated from the console
         /// </value>
-        protected List<Guid> m_pendingConsoleSaves = new List<Guid>();
+        protected List<UUID> m_pendingConsoleTasks = new List<UUID>();
 
         /// <value>
         /// All scenes that this module knows about
@@ -111,6 +111,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             {
                 scene.RegisterModuleInterface<IInventoryArchiverModule>(this);
                 OnInventoryArchiveSaved += SaveInvConsoleCommandCompleted;
+                OnInventoryArchiveLoaded += LoadInvConsoleCommandCompleted;
 
                 scene.AddCommand(
                     "Archiving", this, "load iar",
@@ -139,7 +140,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                     + "-e|--exclude=<name/uuid> don't save the inventory item in archive" + Environment.NewLine
                     + "-f|--excludefolder=<folder/uuid> don't save contents of the folder in archive" + Environment.NewLine
                     + "-v|--verbose extra debug messages.\n"
-                    + "--noassets stops assets being saved to the IAR.",
+                    + "--noassets stops assets being saved to the IAR."
+                    + "--perm=<permissions> stops items with insufficient permissions from being saved to the IAR.\n"
+                    + "   <permissions> can contain one or more of these characters: \"C\" = Copy, \"T\" = Transfer, \"M\" = Modify.\n",
                     HandleSaveInvConsoleCommand);
 
                 m_aScene = scene;
@@ -175,22 +178,34 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// Trigger the inventory archive saved event.
         /// </summary>
         protected internal void TriggerInventoryArchiveSaved(
-            Guid id, bool succeeded, UserAccount userInfo, string invPath, Stream saveStream,
-            Exception reportedException)
+            UUID id, bool succeeded, UserAccount userInfo, string invPath, Stream saveStream,
+            Exception reportedException, int SaveCount, int FilterCount)
         {
             InventoryArchiveSaved handlerInventoryArchiveSaved = OnInventoryArchiveSaved;
             if (handlerInventoryArchiveSaved != null)
-                handlerInventoryArchiveSaved(id, succeeded, userInfo, invPath, saveStream, reportedException);
+                handlerInventoryArchiveSaved(id, succeeded, userInfo, invPath, saveStream, reportedException, SaveCount , FilterCount);
+        }
+
+        /// <summary>
+        /// Trigger the inventory archive loaded event.
+        /// </summary>
+        protected internal void TriggerInventoryArchiveLoaded(
+            UUID id, bool succeeded, UserAccount userInfo, string invPath, Stream loadStream,
+            Exception reportedException, int LoadCount)
+        {
+            InventoryArchiveLoaded handlerInventoryArchiveLoaded = OnInventoryArchiveLoaded;
+            if (handlerInventoryArchiveLoaded != null)
+                handlerInventoryArchiveLoaded(id, succeeded, userInfo, invPath, loadStream, reportedException, LoadCount);
         }
 
         public bool ArchiveInventory(
-             Guid id, string firstName, string lastName, string invPath, string pass, Stream saveStream)
+             UUID id, string firstName, string lastName, string invPath, string pass, Stream saveStream)
         {
             return ArchiveInventory(id, firstName, lastName, invPath, pass, saveStream, new Dictionary<string, object>());
         }
 
         public bool ArchiveInventory(
-            Guid id, string firstName, string lastName, string invPath, string pass, Stream saveStream,
+            UUID id, string firstName, string lastName, string invPath, string pass, Stream saveStream,
             Dictionary<string, object> options)
         {
             if (m_scenes.Count > 0)
@@ -230,7 +245,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         }
 
         public bool ArchiveInventory(
-            Guid id, string firstName, string lastName, string invPath, string pass, string savePath,
+            UUID id, string firstName, string lastName, string invPath, string pass, string savePath,
             Dictionary<string, object> options)
         {
 //            if (!ConsoleUtil.CheckFileDoesNotExist(MainConsole.Instance, savePath))
@@ -272,13 +287,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             return false;
         }
 
-        public bool DearchiveInventory(string firstName, string lastName, string invPath, string pass, Stream loadStream)
+        public bool DearchiveInventory(UUID id, string firstName, string lastName, string invPath, string pass, Stream loadStream)
         {
-            return DearchiveInventory(firstName, lastName, invPath, pass, loadStream, new Dictionary<string, object>());
+            return DearchiveInventory(id, firstName, lastName, invPath, pass, loadStream, new Dictionary<string, object>());
         }
 
         public bool DearchiveInventory(
-            string firstName, string lastName, string invPath, string pass, Stream loadStream,
+            UUID id, string firstName, string lastName, string invPath, string pass, Stream loadStream,
             Dictionary<string, object> options)
         {
             if (m_scenes.Count > 0)
@@ -294,7 +309,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 
                         try
                         {
-                            request = new InventoryArchiveReadRequest(m_aScene, userInfo, invPath, loadStream, merge);
+                            request = new InventoryArchiveReadRequest(id, this, m_aScene.InventoryService, m_aScene.AssetService, m_aScene.UserAccountService, userInfo, invPath, loadStream, merge);
                         }
                         catch (EntryPointNotFoundException e)
                         {
@@ -326,7 +341,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         }
 
         public bool DearchiveInventory(
-             string firstName, string lastName, string invPath, string pass, string loadPath,
+             UUID id, string firstName, string lastName, string invPath, string pass, string loadPath,
              Dictionary<string, object> options)
         {
             if (m_scenes.Count > 0)
@@ -342,7 +357,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
 
                         try
                         {
-                            request = new InventoryArchiveReadRequest(m_aScene, userInfo, invPath, loadPath, merge);
+                            request = new InventoryArchiveReadRequest(id, this, m_aScene.InventoryService, m_aScene.AssetService, m_aScene.UserAccountService, userInfo, invPath, loadPath, merge);
                         }
                         catch (EntryPointNotFoundException e)
                         {
@@ -378,6 +393,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         {
             try
             {
+                UUID id = UUID.Random();
+
                 Dictionary<string, object> options = new Dictionary<string, object>();
                 OptionSet optionSet = new OptionSet().Add("m|merge", delegate (string v) { options["merge"] = v != null; });
 
@@ -400,10 +417,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                     "[INVENTORY ARCHIVER]: Loading archive {0} to inventory path {1} for {2} {3}",
                     loadPath, invPath, firstName, lastName);
 
-                if (DearchiveInventory(firstName, lastName, invPath, pass, loadPath, options))
-                    m_log.InfoFormat(
-                        "[INVENTORY ARCHIVER]: Loaded archive {0} for {1} {2}",
-                        loadPath, firstName, lastName);
+                lock (m_pendingConsoleTasks)
+                    m_pendingConsoleTasks.Add(id);
+
+                DearchiveInventory(id, firstName, lastName, invPath, pass, loadPath, options);
             }
             catch (InventoryArchiverException e)
             {
@@ -417,7 +434,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         /// <param name="cmdparams"></param>
         protected void HandleSaveInvConsoleCommand(string module, string[] cmdparams)
         {
-            Guid id = Guid.NewGuid();
+            UUID id = UUID.Random();
 
             Dictionary<string, object> options = new Dictionary<string, object>();
 
@@ -439,6 +456,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                         options["excludefolders"] = new List<String>();
                     ((List<String>)options["excludefolders"]).Add(v);
                 });
+            ops.Add("perm=", delegate(string v) { options["checkPermissions"] = v; });
 
             List<string> mainParams = ops.Parse(cmdparams);
 
@@ -464,8 +482,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
                     "[INVENTORY ARCHIVER]: Saving archive {0} using inventory path {1} for {2} {3}",
                     savePath, invPath, firstName, lastName);
 
-                lock (m_pendingConsoleSaves)
-                    m_pendingConsoleSaves.Add(id);
+                lock (m_pendingConsoleTasks)
+                    m_pendingConsoleTasks.Add(id);
 
                 ArchiveInventory(id, firstName, lastName, invPath, pass, savePath, options);
             }
@@ -476,20 +494,24 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
         }
 
         private void SaveInvConsoleCommandCompleted(
-            Guid id, bool succeeded, UserAccount userInfo, string invPath, Stream saveStream,
-            Exception reportedException)
+            UUID id, bool succeeded, UserAccount userInfo, string invPath, Stream saveStream,
+            Exception reportedException, int SaveCount, int FilterCount)
         {
-            lock (m_pendingConsoleSaves)
+            lock (m_pendingConsoleTasks)
             {
-                if (m_pendingConsoleSaves.Contains(id))
-                    m_pendingConsoleSaves.Remove(id);
+                if (m_pendingConsoleTasks.Contains(id))
+                    m_pendingConsoleTasks.Remove(id);
                 else
                     return;
             }
 
             if (succeeded)
             {
-                m_log.InfoFormat("[INVENTORY ARCHIVER]: Saved archive for {0} {1}", userInfo.FirstName, userInfo.LastName);
+                // Report success and include item count and filter count (Skipped items due to --perm or --exclude switches)
+                if(FilterCount == 0)
+                    m_log.InfoFormat("[INVENTORY ARCHIVER]: Saved archive with {0} items for {1} {2}", SaveCount, userInfo.FirstName, userInfo.LastName);
+                else
+                    m_log.InfoFormat("[INVENTORY ARCHIVER]: Saved archive with {0} items for {1} {2}. Skipped {3} items due to exclude and/or perm switches", SaveCount, userInfo.FirstName, userInfo.LastName, FilterCount);
             }
             else
             {
@@ -499,6 +521,30 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             }
         }
 
+        private void LoadInvConsoleCommandCompleted(
+            UUID id, bool succeeded, UserAccount userInfo, string invPath, Stream loadStream,
+            Exception reportedException, int LoadCount)
+        {
+            lock (m_pendingConsoleTasks)
+            {
+                if (m_pendingConsoleTasks.Contains(id))
+                    m_pendingConsoleTasks.Remove(id);
+                else
+                    return;
+            }
+
+            if (succeeded)
+            {
+                m_log.InfoFormat("[INVENTORY ARCHIVER]: Loaded {0} items from archive {1} for {2} {3}", LoadCount, invPath, userInfo.FirstName, userInfo.LastName);
+            }
+            else
+            {
+                m_log.ErrorFormat(
+                    "[INVENTORY ARCHIVER]: Archive load for {0} {1} failed - {2}",
+                    userInfo.FirstName, userInfo.LastName, reportedException.Message);
+            }
+        }
+
         /// <summary>
         /// Get user information for the given name.
         /// </summary>
@@ -536,7 +582,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
             }
             catch (Exception e)
             {
-                m_log.ErrorFormat("[INVENTORY ARCHIVER]: Could not authenticate password, {0}", e.Message);
+                m_log.ErrorFormat("[INVENTORY ARCHIVER]: Could not authenticate password, {0}", e);
                 return null;
             }
         }
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/PathTests.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveLoadPathTests.cs
index 6eb3605..c2e645f 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/PathTests.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveLoadPathTests.cs
@@ -36,137 +36,19 @@ using OpenSim.Data;
 using OpenSim.Framework;
 using OpenSim.Framework.Serialization;
 using OpenSim.Framework.Serialization.External;
-using OpenSim.Framework.Communications;
 using OpenSim.Region.CoreModules.Avatar.Inventory.Archiver;
 using OpenSim.Region.CoreModules.World.Serialiser;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 {
     [TestFixture]
-    public class PathTests : InventoryArchiveTestCase
+    public class InventoryArchiveLoadPathTests : InventoryArchiveTestCase
     {
         /// <summary>
-        /// Test saving an inventory path to a V0.1 OpenSim Inventory Archive 
-        /// (subject to change since there is no fixed format yet).
-        /// </summary>
-        [Test]
-        public void TestSavePathToIarV0_1()
-        {
-            TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
-
-            InventoryArchiverModule archiverModule = new InventoryArchiverModule();
-
-            Scene scene = new SceneHelpers().SetupScene();
-            SceneHelpers.SetupSceneModules(scene, archiverModule);
-
-            // Create user
-            string userFirstName = "Jock";
-            string userLastName = "Stirrup";
-            string userPassword = "troll";
-            UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000020");
-            UserAccountHelpers.CreateUserWithInventory(scene, userFirstName, userLastName, userId, userPassword);
-            
-            // Create asset
-            SceneObjectGroup object1;
-            SceneObjectPart part1;
-            {
-                string partName = "My Little Dog Object";
-                UUID ownerId = UUID.Parse("00000000-0000-0000-0000-000000000040");
-                PrimitiveBaseShape shape = PrimitiveBaseShape.CreateSphere();
-                Vector3 groupPosition = new Vector3(10, 20, 30);
-                Quaternion rotationOffset = new Quaternion(20, 30, 40, 50);
-                Vector3 offsetPosition = new Vector3(5, 10, 15);
-
-                part1 = new SceneObjectPart(ownerId, shape, groupPosition, rotationOffset, offsetPosition);
-                part1.Name = partName;
-
-                object1 = new SceneObjectGroup(part1);
-                scene.AddNewSceneObject(object1, false);
-            }
-
-            UUID asset1Id = UUID.Parse("00000000-0000-0000-0000-000000000060");
-            AssetBase asset1 = AssetHelpers.CreateAsset(asset1Id, object1);
-            scene.AssetService.Store(asset1);
-
-            // Create item
-            UUID item1Id = UUID.Parse("00000000-0000-0000-0000-000000000080");
-            InventoryItemBase item1 = new InventoryItemBase();
-            item1.Name = "My Little Dog";
-            item1.AssetID = asset1.FullID;
-            item1.ID = item1Id;
-            InventoryFolderBase objsFolder 
-                = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, userId, "Objects")[0];
-            item1.Folder = objsFolder.ID;
-            scene.AddInventoryItem(item1);
-
-            MemoryStream archiveWriteStream = new MemoryStream();
-            archiverModule.OnInventoryArchiveSaved += SaveCompleted;
-
-            // Test saving a particular path
-            mre.Reset();
-            archiverModule.ArchiveInventory(
-                Guid.NewGuid(), userFirstName, userLastName, "Objects", userPassword, archiveWriteStream);
-            mre.WaitOne(60000, false);
-
-            byte[] archive = archiveWriteStream.ToArray();
-            MemoryStream archiveReadStream = new MemoryStream(archive);
-            TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
-
-            //bool gotControlFile = false;
-            bool gotObject1File = false;
-            //bool gotObject2File = false;
-            string expectedObject1FileName = InventoryArchiveWriteRequest.CreateArchiveItemName(item1);
-            string expectedObject1FilePath = string.Format(
-                "{0}{1}{2}",
-                ArchiveConstants.INVENTORY_PATH,
-                InventoryArchiveWriteRequest.CreateArchiveFolderName(objsFolder),
-                expectedObject1FileName);
-
-            string filePath;
-            TarArchiveReader.TarEntryType tarEntryType;
-
-//            Console.WriteLine("Reading archive");
-            
-            while (tar.ReadEntry(out filePath, out tarEntryType) != null)
-            {
-//                Console.WriteLine("Got {0}", filePath);
-
-//                if (ArchiveConstants.CONTROL_FILE_PATH == filePath)
-//                {
-//                    gotControlFile = true;
-//                }
-                
-                if (filePath.StartsWith(ArchiveConstants.INVENTORY_PATH) && filePath.EndsWith(".xml"))
-                {
-//                    string fileName = filePath.Remove(0, "Objects/".Length);
-//
-//                    if (fileName.StartsWith(part1.Name))
-//                    {
-                        Assert.That(expectedObject1FilePath, Is.EqualTo(filePath));
-                        gotObject1File = true;
-//                    }
-//                    else if (fileName.StartsWith(part2.Name))
-//                    {
-//                        Assert.That(fileName, Is.EqualTo(expectedObject2FileName));
-//                        gotObject2File = true;
-//                    }
-                }
-            }
-
-//            Assert.That(gotControlFile, Is.True, "No control file in archive");
-            Assert.That(gotObject1File, Is.True, "No item1 file in archive");
-//            Assert.That(gotObject2File, Is.True, "No object2 file in archive");
-
-            // TODO: Test presence of more files and contents of files.
-        }
-        
-        /// <summary>
         /// Test loading an IAR to various different inventory paths.
         /// </summary>
         [Test]
@@ -185,26 +67,26 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 
             UserAccountHelpers.CreateUserWithInventory(scene, m_uaMT, "meowfood");
             UserAccountHelpers.CreateUserWithInventory(scene, m_uaLL1, "hampshire");
-            
-            archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/", "meowfood", m_iarStream);            
+
+            archiverModule.DearchiveInventory(UUID.Random(), m_uaMT.FirstName, m_uaMT.LastName, "/", "meowfood", m_iarStream);            
             InventoryItemBase foundItem1
                 = InventoryArchiveUtils.FindItemByPath(scene.InventoryService, m_uaMT.PrincipalID, m_item1Name);
             
             Assert.That(foundItem1, Is.Not.Null, "Didn't find loaded item 1");            
 
             // Now try loading to a root child folder
-            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, m_uaMT.PrincipalID, "xA");
+            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, m_uaMT.PrincipalID, "xA", false);
             MemoryStream archiveReadStream = new MemoryStream(m_iarStream.ToArray());
-            archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "xA", "meowfood", archiveReadStream);
+            archiverModule.DearchiveInventory(UUID.Random(), m_uaMT.FirstName, m_uaMT.LastName, "xA", "meowfood", archiveReadStream);
 
             InventoryItemBase foundItem2
                 = InventoryArchiveUtils.FindItemByPath(scene.InventoryService, m_uaMT.PrincipalID, "xA/" + m_item1Name);
             Assert.That(foundItem2, Is.Not.Null, "Didn't find loaded item 2");
 
             // Now try loading to a more deeply nested folder
-            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, m_uaMT.PrincipalID, "xB/xC");
+            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, m_uaMT.PrincipalID, "xB/xC", false);
             archiveReadStream = new MemoryStream(archiveReadStream.ToArray());
-            archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "xB/xC", "meowfood", archiveReadStream);
+            archiverModule.DearchiveInventory(UUID.Random(), m_uaMT.FirstName, m_uaMT.LastName, "xB/xC", "meowfood", archiveReadStream);
 
             InventoryItemBase foundItem3
                 = InventoryArchiveUtils.FindItemByPath(scene.InventoryService, m_uaMT.PrincipalID, "xB/xC/" + m_item1Name);
@@ -226,7 +108,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             SceneHelpers.SetupSceneModules(scene, serialiserModule, archiverModule);
             
             UserAccountHelpers.CreateUserWithInventory(scene, m_uaMT, "password");
-            archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/Objects", "password", m_iarStream);
+            archiverModule.DearchiveInventory(UUID.Random(), m_uaMT.FirstName, m_uaMT.LastName, "/Objects", "password", m_iarStream);
 
             InventoryItemBase foundItem1
                 = InventoryArchiveUtils.FindItemByPath(
@@ -287,7 +169,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             item1.AssetID = asset1.FullID;
             item1.ID = item1Id;
             InventoryFolderBase objsFolder 
-                = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, userId, "Objects")[0];
+                = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, userId, "Objects")[0];
             item1.Folder = objsFolder.ID;
             scene.AddInventoryItem(item1);
 
@@ -296,13 +178,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 
             mre.Reset();
             archiverModule.ArchiveInventory(
-                Guid.NewGuid(), userFirstName, userLastName, "Objects", userPassword, archiveWriteStream);
+                UUID.Random(), userFirstName, userLastName, "Objects", userPassword, archiveWriteStream);
             mre.WaitOne(60000, false);
 
             // LOAD ITEM
             MemoryStream archiveReadStream = new MemoryStream(archiveWriteStream.ToArray());
-            
-            archiverModule.DearchiveInventory(userFirstName, userLastName, "Scripts", userPassword, archiveReadStream);
+
+            archiverModule.DearchiveInventory(UUID.Random(), userFirstName, userLastName, "Scripts", userPassword, archiveReadStream);
 
             InventoryItemBase foundItem1
                 = InventoryArchiveUtils.FindItemByPath(
@@ -345,40 +227,40 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 
             {
                 // Test replication of path1
-                new InventoryArchiveReadRequest(scene, ua1, null, (Stream)null, false)
+                new InventoryArchiveReadRequest(UUID.Random(), null, scene.InventoryService, scene.AssetService, scene.UserAccountService, ua1, null, (Stream)null, false)
                     .ReplicateArchivePathToUserInventory(
                         iarPath1, scene.InventoryService.GetRootFolder(ua1.PrincipalID), 
                         foldersCreated, nodesLoaded);
     
                 List<InventoryFolderBase> folder1Candidates
-                    = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, ua1.PrincipalID, folder1Name);
+                    = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, ua1.PrincipalID, folder1Name);
                 Assert.That(folder1Candidates.Count, Is.EqualTo(1));
                 
                 InventoryFolderBase folder1 = folder1Candidates[0];
                 List<InventoryFolderBase> folder2aCandidates 
-                    = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, folder1, folder2aName);
+                    = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, folder1, folder2aName);
                 Assert.That(folder2aCandidates.Count, Is.EqualTo(1));
             }
             
             {
                 // Test replication of path2
-                new InventoryArchiveReadRequest(scene, ua1, null, (Stream)null, false)
+                new InventoryArchiveReadRequest(UUID.Random(), null, scene.InventoryService, scene.AssetService, scene.UserAccountService, ua1, null, (Stream)null, false)
                     .ReplicateArchivePathToUserInventory(
                         iarPath2, scene.InventoryService.GetRootFolder(ua1.PrincipalID), 
                         foldersCreated, nodesLoaded);
     
                 List<InventoryFolderBase> folder1Candidates
-                    = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, ua1.PrincipalID, folder1Name);
+                    = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, ua1.PrincipalID, folder1Name);
                 Assert.That(folder1Candidates.Count, Is.EqualTo(1));
                 
                 InventoryFolderBase folder1 = folder1Candidates[0]; 
                 
                 List<InventoryFolderBase> folder2aCandidates 
-                    = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, folder1, folder2aName);
+                    = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, folder1, folder2aName);
                 Assert.That(folder2aCandidates.Count, Is.EqualTo(1));
                 
                 List<InventoryFolderBase> folder2bCandidates 
-                    = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, folder1, folder2bName);
+                    = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, folder1, folder2bName);
                 Assert.That(folder2bCandidates.Count, Is.EqualTo(1));
             }
         }
@@ -401,20 +283,20 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             
             InventoryFolderBase folder1 
                 = UserInventoryHelpers.CreateInventoryFolder(
-                    scene.InventoryService, ua1.PrincipalID, folder1ExistingName);
+                    scene.InventoryService, ua1.PrincipalID, folder1ExistingName, false);
             
             string folder1ArchiveName = InventoryArchiveWriteRequest.CreateArchiveFolderName(folder1ExistingName, UUID.Random());
             string folder2ArchiveName = InventoryArchiveWriteRequest.CreateArchiveFolderName(folder2Name, UUID.Random());
             
             string itemArchivePath = string.Join("", new string[] { folder1ArchiveName, folder2ArchiveName });
-            
-            new InventoryArchiveReadRequest(scene, ua1, null, (Stream)null, false)
+
+            new InventoryArchiveReadRequest(UUID.Random(), null, scene.InventoryService, scene.AssetService, scene.UserAccountService, ua1, null, (Stream)null, false)
                 .ReplicateArchivePathToUserInventory(
                     itemArchivePath, scene.InventoryService.GetRootFolder(ua1.PrincipalID), 
                     new Dictionary<string, InventoryFolderBase>(), new HashSet<InventoryNodeBase>());
 
             List<InventoryFolderBase> folder1PostCandidates 
-                = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, ua1.PrincipalID, folder1ExistingName);
+                = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, ua1.PrincipalID, folder1ExistingName);
             Assert.That(folder1PostCandidates.Count, Is.EqualTo(2));
             
             // FIXME: Temporarily, we're going to do something messy to make sure we pick up the created folder.
@@ -430,7 +312,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 //            Assert.That(folder1Post.ID, Is.EqualTo(folder1.ID));
 
             List<InventoryFolderBase> folder2PostCandidates 
-                = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, folder1Post, "b");
+                = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, folder1Post, "b");
             Assert.That(folder2PostCandidates.Count, Is.EqualTo(1));
         }
         
@@ -452,26 +334,27 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             
             InventoryFolderBase folder1 
                 = UserInventoryHelpers.CreateInventoryFolder(
-                    scene.InventoryService, ua1.PrincipalID, folder1ExistingName);
+                    scene.InventoryService, ua1.PrincipalID, folder1ExistingName, false);
             
             string folder1ArchiveName = InventoryArchiveWriteRequest.CreateArchiveFolderName(folder1ExistingName, UUID.Random());
             string folder2ArchiveName = InventoryArchiveWriteRequest.CreateArchiveFolderName(folder2Name, UUID.Random());
             
             string itemArchivePath = string.Join("", new string[] { folder1ArchiveName, folder2ArchiveName });
-            
-            new InventoryArchiveReadRequest(scene, ua1, folder1ExistingName, (Stream)null, true)
+
+            new InventoryArchiveReadRequest(UUID.Random(), null, scene.InventoryService, scene.AssetService, scene.UserAccountService, ua1, folder1ExistingName, (Stream)null, true)
                 .ReplicateArchivePathToUserInventory(
                     itemArchivePath, scene.InventoryService.GetRootFolder(ua1.PrincipalID), 
                     new Dictionary<string, InventoryFolderBase>(), new HashSet<InventoryNodeBase>());
 
             List<InventoryFolderBase> folder1PostCandidates 
-                = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, ua1.PrincipalID, folder1ExistingName);
+                = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, ua1.PrincipalID, folder1ExistingName);
             Assert.That(folder1PostCandidates.Count, Is.EqualTo(1));
             Assert.That(folder1PostCandidates[0].ID, Is.EqualTo(folder1.ID));
 
             List<InventoryFolderBase> folder2PostCandidates 
-                = InventoryArchiveUtils.FindFolderByPath(scene.InventoryService, folder1PostCandidates[0], "b");
+                = InventoryArchiveUtils.FindFoldersByPath(scene.InventoryService, folder1PostCandidates[0], "b");
             Assert.That(folder2PostCandidates.Count, Is.EqualTo(1));
         }
     }
-}
\ No newline at end of file
+}
+
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveLoadTests.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveLoadTests.cs
new file mode 100644
index 0000000..57b4f80
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveLoadTests.cs
@@ -0,0 +1,192 @@
+/*
+ * 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.IO;
+using System.Reflection;
+using System.Threading;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Data;
+using OpenSim.Framework;
+using OpenSim.Framework.Serialization;
+using OpenSim.Framework.Serialization.External;
+using OpenSim.Region.CoreModules.Avatar.Inventory.Archiver;
+using OpenSim.Region.CoreModules.World.Serialiser;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Scenes.Serialization;
+using OpenSim.Services.Interfaces;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
+{
+    [TestFixture]
+    public class InventoryArchiveLoadTests : InventoryArchiveTestCase
+    {               
+        protected TestScene m_scene;
+        protected InventoryArchiverModule m_archiverModule;
+
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+            
+            SerialiserModule serialiserModule = new SerialiserModule();
+            m_archiverModule = new InventoryArchiverModule();
+
+            m_scene = new SceneHelpers().SetupScene();
+            SceneHelpers.SetupSceneModules(m_scene, serialiserModule, m_archiverModule);            
+        }
+
+        [Test]
+        public void TestLoadCoalesecedItem()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL1, "password");
+            m_archiverModule.DearchiveInventory(UUID.Random(), m_uaLL1.FirstName, m_uaLL1.LastName, "/", "password", m_iarStream);            
+            
+            InventoryItemBase coaItem
+                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaLL1.PrincipalID, m_coaItemName);
+            
+            Assert.That(coaItem, Is.Not.Null, "Didn't find loaded item 1");            
+            
+            string assetXml = AssetHelpers.ReadAssetAsString(m_scene.AssetService, coaItem.AssetID);
+            
+            CoalescedSceneObjects coa;            
+            bool readResult = CoalescedSceneObjectsSerializer.TryFromXml(assetXml, out coa);
+            
+            Assert.That(readResult, Is.True);
+            Assert.That(coa.Count, Is.EqualTo(2));
+            
+            List<SceneObjectGroup> coaObjects = coa.Objects;
+            Assert.That(coaObjects[0].UUID, Is.EqualTo(UUID.Parse("00000000-0000-0000-0000-000000000120")));
+            Assert.That(coaObjects[0].AbsolutePosition, Is.EqualTo(new Vector3(15, 30, 45)));
+            
+            Assert.That(coaObjects[1].UUID, Is.EqualTo(UUID.Parse("00000000-0000-0000-0000-000000000140")));
+            Assert.That(coaObjects[1].AbsolutePosition, Is.EqualTo(new Vector3(25, 50, 75)));            
+        }   
+
+        /// <summary>
+        /// Test case where a creator account exists for the creator UUID embedded in item metadata and serialized
+        /// objects.
+        /// </summary>        
+        [Test]
+        public void TestLoadIarCreatorAccountPresent()
+        {
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL1, "meowfood");
+
+            m_archiverModule.DearchiveInventory(UUID.Random(), m_uaLL1.FirstName, m_uaLL1.LastName, "/", "meowfood", m_iarStream);            
+            InventoryItemBase foundItem1
+                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaLL1.PrincipalID, m_item1Name);
+
+            Assert.That(
+                foundItem1.CreatorId, Is.EqualTo(m_uaLL1.PrincipalID.ToString()), 
+                "Loaded item non-uuid creator doesn't match original");            
+            Assert.That(
+                foundItem1.CreatorIdAsUuid, Is.EqualTo(m_uaLL1.PrincipalID), 
+                "Loaded item uuid creator doesn't match original");
+            Assert.That(foundItem1.Owner, Is.EqualTo(m_uaLL1.PrincipalID),
+                "Loaded item owner doesn't match inventory reciever");
+            
+            AssetBase asset1 = m_scene.AssetService.Get(foundItem1.AssetID.ToString());            
+            string xmlData = Utils.BytesToString(asset1.Data);
+            SceneObjectGroup sog1 = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
+            
+            Assert.That(sog1.RootPart.CreatorID, Is.EqualTo(m_uaLL1.PrincipalID));            
+        }
+        
+//        /// <summary>
+//        /// Test loading a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet) where
+//        /// an account exists with the same name as the creator, though not the same id.
+//        /// </summary>
+//        [Test]
+//        public void TestLoadIarV0_1SameNameCreator()
+//        {
+//            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+//
+//            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaMT, "meowfood");
+//            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL2, "hampshire");
+//            
+//            m_archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/", "meowfood", m_iarStream);            
+//            InventoryItemBase foundItem1
+//                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaMT.PrincipalID, m_item1Name);
+//
+//            Assert.That(
+//                foundItem1.CreatorId, Is.EqualTo(m_uaLL2.PrincipalID.ToString()), 
+//                "Loaded item non-uuid creator doesn't match original");            
+//            Assert.That(
+//                foundItem1.CreatorIdAsUuid, Is.EqualTo(m_uaLL2.PrincipalID), 
+//                "Loaded item uuid creator doesn't match original");
+//            Assert.That(foundItem1.Owner, Is.EqualTo(m_uaMT.PrincipalID),
+//                "Loaded item owner doesn't match inventory reciever");
+//            
+//            AssetBase asset1 = m_scene.AssetService.Get(foundItem1.AssetID.ToString());            
+//            string xmlData = Utils.BytesToString(asset1.Data);
+//            SceneObjectGroup sog1 = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
+//            
+//            Assert.That(sog1.RootPart.CreatorID, Is.EqualTo(m_uaLL2.PrincipalID));
+//        }
+
+        /// <summary>
+        /// Test loading a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet) where
+        /// the creator or an account with the creator's name does not exist within the system.
+        /// </summary>
+        [Test]
+        public void TestLoadIarV0_1AbsentCreator()
+        {
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+            
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaMT, "password");
+            m_archiverModule.DearchiveInventory(UUID.Random(), m_uaMT.FirstName, m_uaMT.LastName, "/", "password", m_iarStream);
+
+            InventoryItemBase foundItem1
+                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaMT.PrincipalID, m_item1Name);
+            
+            Assert.That(foundItem1, Is.Not.Null, "Didn't find loaded item 1");
+            Assert.That(
+                foundItem1.CreatorId, Is.EqualTo(m_uaMT.PrincipalID.ToString()), 
+                "Loaded item non-uuid creator doesn't match that of the loading user");
+            Assert.That(
+                foundItem1.CreatorIdAsUuid, Is.EqualTo(m_uaMT.PrincipalID), 
+                "Loaded item uuid creator doesn't match that of the loading user");
+            
+            AssetBase asset1 = m_scene.AssetService.Get(foundItem1.AssetID.ToString());            
+            string xmlData = Utils.BytesToString(asset1.Data);
+            SceneObjectGroup sog1 = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
+            
+            Assert.That(sog1.RootPart.CreatorID, Is.EqualTo(m_uaMT.PrincipalID));            
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveSaveTests.cs
index 06f6e49..7265405 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveSaveTests.cs
@@ -36,19 +36,17 @@ using OpenSim.Data;
 using OpenSim.Framework;
 using OpenSim.Framework.Serialization;
 using OpenSim.Framework.Serialization.External;
-using OpenSim.Framework.Communications;
 using OpenSim.Region.CoreModules.Avatar.Inventory.Archiver;
 using OpenSim.Region.CoreModules.World.Serialiser;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 {
     [TestFixture]
-    public class InventoryArchiverTests : InventoryArchiveTestCase
+    public class InventoryArchiveSaveTests : InventoryArchiveTestCase
     {
         protected TestScene m_scene;
         protected InventoryArchiverModule m_archiverModule;
@@ -64,36 +62,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             m_scene = new SceneHelpers().SetupScene();
             SceneHelpers.SetupSceneModules(m_scene, serialiserModule, m_archiverModule);            
         }
-                
-        [Test]
-        public void TestLoadCoalesecedItem()
-        {
-            TestHelpers.InMethod();
-//            TestHelpers.EnableLogging();
-            
-            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL1, "password");
-            m_archiverModule.DearchiveInventory(m_uaLL1.FirstName, m_uaLL1.LastName, "/", "password", m_iarStream);            
-            
-            InventoryItemBase coaItem
-                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaLL1.PrincipalID, m_coaItemName);
-            
-            Assert.That(coaItem, Is.Not.Null, "Didn't find loaded item 1");            
-            
-            string assetXml = AssetHelpers.ReadAssetAsString(m_scene.AssetService, coaItem.AssetID);
-            
-            CoalescedSceneObjects coa;            
-            bool readResult = CoalescedSceneObjectsSerializer.TryFromXml(assetXml, out coa);
-            
-            Assert.That(readResult, Is.True);
-            Assert.That(coa.Count, Is.EqualTo(2));
-            
-            List<SceneObjectGroup> coaObjects = coa.Objects;
-            Assert.That(coaObjects[0].UUID, Is.EqualTo(UUID.Parse("00000000-0000-0000-0000-000000000120")));
-            Assert.That(coaObjects[0].AbsolutePosition, Is.EqualTo(new Vector3(15, 30, 45)));
-            
-            Assert.That(coaObjects[1].UUID, Is.EqualTo(UUID.Parse("00000000-0000-0000-0000-000000000140")));
-            Assert.That(coaObjects[1].AbsolutePosition, Is.EqualTo(new Vector3(25, 50, 75)));            
-        }   
         
         /// <summary>
         /// Test that the IAR has the required files in the right order.
@@ -115,12 +83,145 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             byte[] data = tar.ReadEntry(out filePath, out tarEntryType);
             Assert.That(filePath, Is.EqualTo(ArchiveConstants.CONTROL_FILE_PATH));
             
-            InventoryArchiveReadRequest iarr 
-                = new InventoryArchiveReadRequest(null, null, null, (Stream)null, false);
+            InventoryArchiveReadRequest iarr
+                = new InventoryArchiveReadRequest(UUID.Random(), null, null, null, null, null, null, (Stream)null, false);
             iarr.LoadControlFile(filePath, data);
             
             Assert.That(iarr.ControlFileLoaded, Is.True);
         }
+
+        [Test]
+        public void TestSaveRootFolderToIar()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            string userFirstName = "Jock";
+            string userLastName = "Stirrup";
+            string userPassword = "troll";
+            UUID userId = TestHelpers.ParseTail(0x20);
+
+            UserAccountHelpers.CreateUserWithInventory(m_scene, userFirstName, userLastName, userId, userPassword);
+
+            MemoryStream archiveWriteStream = new MemoryStream();
+            m_archiverModule.OnInventoryArchiveSaved += SaveCompleted;
+
+            mre.Reset();
+            m_archiverModule.ArchiveInventory(
+                UUID.Random(), userFirstName, userLastName, "/", userPassword, archiveWriteStream);
+            mre.WaitOne(60000, false);
+
+            // Test created iar
+            byte[] archive = archiveWriteStream.ToArray();
+            MemoryStream archiveReadStream = new MemoryStream(archive);
+            TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
+
+//            InventoryArchiveUtils.
+            bool gotObjectsFolder = false;
+
+            string objectsFolderName 
+                = string.Format(
+                    "{0}{1}", 
+                    ArchiveConstants.INVENTORY_PATH, 
+                    InventoryArchiveWriteRequest.CreateArchiveFolderName(
+                        UserInventoryHelpers.GetInventoryFolder(m_scene.InventoryService, userId, "Objects")));
+
+            string filePath;
+            TarArchiveReader.TarEntryType tarEntryType;
+            
+            while (tar.ReadEntry(out filePath, out tarEntryType) != null)
+            {
+//                Console.WriteLine("Got {0}", filePath);
+
+                // Lazily, we only bother to look for the system objects folder created when we call CreateUserWithInventory()
+                // XXX: But really we need to stop all that stuff being created in tests or check for such folders 
+                // more thoroughly
+                if (filePath == objectsFolderName)
+                    gotObjectsFolder = true;
+            }
+
+            Assert.That(gotObjectsFolder, Is.True);
+        }
+
+        [Test]
+        public void TestSaveNonRootFolderToIar()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            string userFirstName = "Jock";
+            string userLastName = "Stirrup";
+            string userPassword = "troll";
+            UUID userId = TestHelpers.ParseTail(0x20);
+
+            UserAccountHelpers.CreateUserWithInventory(m_scene, userFirstName, userLastName, userId, userPassword);
+
+            // Create base folder
+            InventoryFolderBase f1 
+                = UserInventoryHelpers.CreateInventoryFolder(m_scene.InventoryService, userId, "f1", true);
+            
+            // Create item1
+            SceneObjectGroup so1 = SceneHelpers.CreateSceneObject(1, userId, "My Little Dog Object", 0x5);         
+            InventoryItemBase i1 = UserInventoryHelpers.AddInventoryItem(m_scene, so1, 0x50, 0x60, "f1");
+
+            // Create embedded folder
+            InventoryFolderBase f1_1 
+                = UserInventoryHelpers.CreateInventoryFolder(m_scene.InventoryService, userId, "f1/f1.1", true);
+
+            // Create embedded item
+            SceneObjectGroup so1_1 = SceneHelpers.CreateSceneObject(1, userId, "My Little Cat Object", 0x6);         
+            InventoryItemBase i2 = UserInventoryHelpers.AddInventoryItem(m_scene, so1_1, 0x500, 0x600, "f1/f1.1");
+
+            MemoryStream archiveWriteStream = new MemoryStream();
+            m_archiverModule.OnInventoryArchiveSaved += SaveCompleted;
+
+            mre.Reset();
+            m_archiverModule.ArchiveInventory(
+                UUID.Random(), userFirstName, userLastName, "f1", userPassword, archiveWriteStream);
+            mre.WaitOne(60000, false);
+
+            // Test created iar
+            byte[] archive = archiveWriteStream.ToArray();
+            MemoryStream archiveReadStream = new MemoryStream(archive);
+            TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
+
+//            InventoryArchiveUtils.
+            bool gotf1 = false, gotf1_1 = false, gotso1 = false, gotso2 = false;
+
+            string f1FileName 
+                = string.Format("{0}{1}", ArchiveConstants.INVENTORY_PATH, InventoryArchiveWriteRequest.CreateArchiveFolderName(f1));
+            string f1_1FileName 
+                = string.Format("{0}{1}", f1FileName, InventoryArchiveWriteRequest.CreateArchiveFolderName(f1_1));
+            string so1FileName 
+                = string.Format("{0}{1}", f1FileName, InventoryArchiveWriteRequest.CreateArchiveItemName(i1));
+            string so2FileName
+                = string.Format("{0}{1}", f1_1FileName, InventoryArchiveWriteRequest.CreateArchiveItemName(i2));
+
+            string filePath;
+            TarArchiveReader.TarEntryType tarEntryType;
+            
+            while (tar.ReadEntry(out filePath, out tarEntryType) != null)
+            {
+//                Console.WriteLine("Got {0}", filePath);
+
+                if (filePath == f1FileName)
+                    gotf1 = true;
+                else if (filePath == f1_1FileName)
+                    gotf1_1 = true;
+                else if (filePath == so1FileName)
+                    gotso1 = true;
+                else if (filePath == so2FileName)
+                    gotso2 = true;
+            }
+
+//            Assert.That(gotControlFile, Is.True, "No control file in archive");
+            Assert.That(gotf1, Is.True);
+            Assert.That(gotf1_1, Is.True);
+            Assert.That(gotso1, Is.True);
+            Assert.That(gotso2, Is.True);
+
+            // TODO: Test presence of more files and contents of files.
+        }
         
         /// <summary>
         /// Test saving a single inventory item to an IAR
@@ -155,7 +256,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             item1.AssetID = asset1.FullID;
             item1.ID = item1Id;
             InventoryFolderBase objsFolder 
-                = InventoryArchiveUtils.FindFolderByPath(m_scene.InventoryService, userId, "Objects")[0];
+                = InventoryArchiveUtils.FindFoldersByPath(m_scene.InventoryService, userId, "Objects")[0];
             item1.Folder = objsFolder.ID;
             m_scene.AddInventoryItem(item1);
 
@@ -164,7 +265,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 
             mre.Reset();
             m_archiverModule.ArchiveInventory(
-                Guid.NewGuid(), userFirstName, userLastName, "Objects/" + item1Name, userPassword, archiveWriteStream);
+                UUID.Random(), userFirstName, userLastName, "Objects/" + item1Name, userPassword, archiveWriteStream);
             mre.WaitOne(60000, false);
 
             byte[] archive = archiveWriteStream.ToArray();
@@ -250,7 +351,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             item1.AssetID = asset1.FullID;
             item1.ID = item1Id;
             InventoryFolderBase objsFolder
-                = InventoryArchiveUtils.FindFolderByPath(m_scene.InventoryService, userId, "Objects")[0];
+                = InventoryArchiveUtils.FindFoldersByPath(m_scene.InventoryService, userId, "Objects")[0];
             item1.Folder = objsFolder.ID;
             m_scene.AddInventoryItem(item1);
 
@@ -261,7 +362,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 
             // When we're not saving assets, archiving is being done synchronously.
             m_archiverModule.ArchiveInventory(
-                Guid.NewGuid(), userFirstName, userLastName, "Objects/" + item1Name, userPassword, archiveWriteStream, options);
+                UUID.Random(), userFirstName, userLastName, "Objects/" + item1Name, userPassword, archiveWriteStream, options);
 
             byte[] archive = archiveWriteStream.ToArray();
             MemoryStream archiveReadStream = new MemoryStream(archive);
@@ -317,101 +418,5 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 
             // TODO: Test presence of more files and contents of files.
         }
-        
-        /// <summary>
-        /// Test case where a creator account exists for the creator UUID embedded in item metadata and serialized
-        /// objects.
-        /// </summary>        
-        [Test]
-        public void TestLoadIarCreatorAccountPresent()
-        {
-            TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
-
-            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL1, "meowfood");
-            
-            m_archiverModule.DearchiveInventory(m_uaLL1.FirstName, m_uaLL1.LastName, "/", "meowfood", m_iarStream);            
-            InventoryItemBase foundItem1
-                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaLL1.PrincipalID, m_item1Name);
-
-            Assert.That(
-                foundItem1.CreatorId, Is.EqualTo(m_uaLL1.PrincipalID.ToString()), 
-                "Loaded item non-uuid creator doesn't match original");            
-            Assert.That(
-                foundItem1.CreatorIdAsUuid, Is.EqualTo(m_uaLL1.PrincipalID), 
-                "Loaded item uuid creator doesn't match original");
-            Assert.That(foundItem1.Owner, Is.EqualTo(m_uaLL1.PrincipalID),
-                "Loaded item owner doesn't match inventory reciever");
-            
-            AssetBase asset1 = m_scene.AssetService.Get(foundItem1.AssetID.ToString());            
-            string xmlData = Utils.BytesToString(asset1.Data);
-            SceneObjectGroup sog1 = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
-            
-            Assert.That(sog1.RootPart.CreatorID, Is.EqualTo(m_uaLL1.PrincipalID));            
-        }
-        
-//        /// <summary>
-//        /// Test loading a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet) where
-//        /// an account exists with the same name as the creator, though not the same id.
-//        /// </summary>
-//        [Test]
-//        public void TestLoadIarV0_1SameNameCreator()
-//        {
-//            TestHelpers.InMethod();
-//            TestHelpers.EnableLogging();
-//
-//            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaMT, "meowfood");
-//            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL2, "hampshire");
-//            
-//            m_archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/", "meowfood", m_iarStream);            
-//            InventoryItemBase foundItem1
-//                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaMT.PrincipalID, m_item1Name);
-//
-//            Assert.That(
-//                foundItem1.CreatorId, Is.EqualTo(m_uaLL2.PrincipalID.ToString()), 
-//                "Loaded item non-uuid creator doesn't match original");            
-//            Assert.That(
-//                foundItem1.CreatorIdAsUuid, Is.EqualTo(m_uaLL2.PrincipalID), 
-//                "Loaded item uuid creator doesn't match original");
-//            Assert.That(foundItem1.Owner, Is.EqualTo(m_uaMT.PrincipalID),
-//                "Loaded item owner doesn't match inventory reciever");
-//            
-//            AssetBase asset1 = m_scene.AssetService.Get(foundItem1.AssetID.ToString());            
-//            string xmlData = Utils.BytesToString(asset1.Data);
-//            SceneObjectGroup sog1 = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
-//            
-//            Assert.That(sog1.RootPart.CreatorID, Is.EqualTo(m_uaLL2.PrincipalID));
-//        }
-
-        /// <summary>
-        /// Test loading a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet) where
-        /// the creator or an account with the creator's name does not exist within the system.
-        /// </summary>
-        [Test]
-        public void TestLoadIarV0_1AbsentCreator()
-        {
-            TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
-            
-            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaMT, "password");
-            m_archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/", "password", m_iarStream);
-
-            InventoryItemBase foundItem1
-                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaMT.PrincipalID, m_item1Name);
-            
-            Assert.That(foundItem1, Is.Not.Null, "Didn't find loaded item 1");
-            Assert.That(
-                foundItem1.CreatorId, Is.EqualTo(m_uaMT.PrincipalID.ToString()), 
-                "Loaded item non-uuid creator doesn't match that of the loading user");
-            Assert.That(
-                foundItem1.CreatorIdAsUuid, Is.EqualTo(m_uaMT.PrincipalID), 
-                "Loaded item uuid creator doesn't match that of the loading user");
-            
-            AssetBase asset1 = m_scene.AssetService.Get(foundItem1.AssetID.ToString());            
-            string xmlData = Utils.BytesToString(asset1.Data);
-            SceneObjectGroup sog1 = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
-            
-            Assert.That(sog1.RootPart.CreatorID, Is.EqualTo(m_uaMT.PrincipalID));            
-        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs
index db78da9..519c697 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs
@@ -36,14 +36,12 @@ using OpenSim.Data;
 using OpenSim.Framework;
 using OpenSim.Framework.Serialization;
 using OpenSim.Framework.Serialization.External;
-using OpenSim.Framework.Communications;
 using OpenSim.Region.CoreModules.Avatar.Inventory.Archiver;
 using OpenSim.Region.CoreModules.World.Serialiser;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
 
 namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 {
@@ -163,14 +161,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             scene.AddInventoryItem(coaItem);            
             
             archiverModule.ArchiveInventory(
-                Guid.NewGuid(), m_uaLL1.FirstName, m_uaLL1.LastName, "/*", "hampshire", archiveWriteStream);            
+                UUID.Random(), m_uaLL1.FirstName, m_uaLL1.LastName, "/*", "hampshire", archiveWriteStream);            
             
             m_iarStreamBytes = archiveWriteStream.ToArray();
         }
         
         protected void SaveCompleted(
-            Guid id, bool succeeded, UserAccount userInfo, string invPath, Stream saveStream, 
-            Exception reportedException)
+            UUID id, bool succeeded, UserAccount userInfo, string invPath, Stream saveStream, 
+            Exception reportedException, int SaveCount, int FilterCount)
         {
             mre.Set();
         }        
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs
index bcb7f42..bba48cc 100644
--- a/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs
@@ -47,10 +47,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
 
         /// <summary>
         private List<Scene> m_Scenelist = new List<Scene>();
-//        private Dictionary<UUID, Scene> m_AgentRegions =
-//                new Dictionary<UUID, Scene>();
 
-        private IMessageTransferModule m_TransferModule = null;
+        private IMessageTransferModule m_TransferModule;
         private bool m_Enabled = true;
 
         #region Region Module interface
@@ -81,9 +79,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
 //            scene.RegisterModuleInterface<IInventoryTransferModule>(this);
 
             scene.EventManager.OnNewClient += OnNewClient;
-//            scene.EventManager.OnClientClosed += ClientLoggedOut;
             scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
-//            scene.EventManager.OnSetRootAgentScene += OnSetRootAgentScene;
         }
 
         public void RegionLoaded(Scene scene)
@@ -96,11 +92,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
                     m_log.Error("[INVENTORY TRANSFER]: No Message transfer module found, transfers will be local only");
                     m_Enabled = false;
 
-                    m_Scenelist.Clear();
-                    scene.EventManager.OnNewClient -= OnNewClient;
-//                    scene.EventManager.OnClientClosed -= ClientLoggedOut;
+//                    m_Scenelist.Clear();
+//                    scene.EventManager.OnNewClient -= OnNewClient;
                     scene.EventManager.OnIncomingInstantMessage -= OnGridInstantMessage;
-//                    scene.EventManager.OnSetRootAgentScene -= OnSetRootAgentScene;
                 }
             }
         }
@@ -108,9 +102,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
         public void RemoveRegion(Scene scene)
         {
             scene.EventManager.OnNewClient -= OnNewClient;
-//            scene.EventManager.OnClientClosed -= ClientLoggedOut;
             scene.EventManager.OnIncomingInstantMessage -= OnGridInstantMessage;
-//            scene.EventManager.OnSetRootAgentScene -= OnSetRootAgentScene;
             m_Scenelist.Remove(scene);
         }
 
@@ -139,11 +131,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
             // Inventory giving is conducted via instant message
             client.OnInstantMessage += OnInstantMessage;
         }
-        
-//        protected void OnSetRootAgentScene(UUID id, Scene scene)
-//        {
-//            m_AgentRegions[id] = scene;
-//        }
 
         private Scene FindClientScene(UUID agentId)
         {
@@ -162,8 +149,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
         private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
         {
 //            m_log.DebugFormat(
-//                "[INVENTORY TRANSFER]: {0} IM type received from {1}", 
-//                (InstantMessageDialog)im.dialog, client.Name);
+//                "[INVENTORY TRANSFER]: {0} IM type received from client {1}. From={2} ({3}), To={4}", 
+//                (InstantMessageDialog)im.dialog, client.Name,
+//                im.fromAgentID, im.fromAgentName, im.toAgentID);
           
             Scene scene = FindClientScene(client.AgentId);
 
@@ -188,12 +176,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
                 {
                     UUID folderID = new UUID(im.binaryBucket, 1);
                     
-                    m_log.DebugFormat("[INVENTORY TRANSFER]: Inserting original folder {0} "+
-                            "into agent {1}'s inventory",
-                            folderID, new UUID(im.toAgentID));
+                    m_log.DebugFormat(
+                        "[INVENTORY TRANSFER]: Inserting original folder {0} into agent {1}'s inventory",
+                        folderID, new UUID(im.toAgentID));
                     
-                    InventoryFolderBase folderCopy 
-                        = scene.GiveInventoryFolder(receipientID, client.AgentId, folderID, UUID.Zero);
+                    InventoryFolderBase folderCopy
+                        = scene.GiveInventoryFolder(client, receipientID, client.AgentId, folderID, UUID.Zero);
                     
                     if (folderCopy == null)
                     {
@@ -213,7 +201,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
                         user.ControllingClient.SendBulkUpdateInventory(folderCopy);
 
                     // HACK!!
-                    im.imSessionID = folderID.Guid;
+                    // Insert the ID of the copied folder into the IM so that we know which item to move to trash if it
+                    // is rejected.
+                    // XXX: This is probably a misuse of the session ID slot.
+                    im.imSessionID = copyID.Guid;
                 }
                 else
                 {
@@ -226,13 +217,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
                             "into agent {1}'s inventory",
                             itemID, new UUID(im.toAgentID));
 
-                    InventoryItemBase itemCopy = scene.GiveInventoryItem(
-                            new UUID(im.toAgentID),
-                            client.AgentId, itemID);
+                    string message;
+                    InventoryItemBase itemCopy = scene.GiveInventoryItem(new UUID(im.toAgentID), client.AgentId, itemID, out message);
 
                     if (itemCopy == null)
                     {
-                        client.SendAgentAlertMessage("Can't find item to give. Nothing given.", false);
+                        client.SendAgentAlertMessage(message, false);
                         return;
                     }
                     
@@ -243,7 +233,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
                         user.ControllingClient.SendBulkUpdateInventory(itemCopy);
 
                     // HACK!!
-                    im.imSessionID = itemID.Guid;
+                    // Insert the ID of the copied item into the IM so that we know which item to move to trash if it
+                    // is rejected.
+                    // XXX: This is probably a misuse of the session ID slot.
+                    im.imSessionID = copyID.Guid;
                 }
 
                 // Send the IM to the recipient. The item is already
@@ -379,7 +372,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
                 IInventoryService invService = scene.InventoryService;
 
                 InventoryFolderBase trashFolder =
-                    invService.GetFolderForType(client.AgentId, AssetType.TrashFolder);
+                    invService.GetFolderForType(client.AgentId, FolderType.Trash);
 
                 UUID inventoryID = new UUID(im.imSessionID); // The inventory item/folder, back from it's trip
 
@@ -403,7 +396,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
                 {
                     folder = new InventoryFolderBase(inventoryID, client.AgentId);
                     folder = invService.GetFolder(folder);
-                    
+
                     if (folder != null & trashFolder != null)
                     {
                         previousParentFolderID = folder.ParentID;
@@ -454,90 +447,61 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
             }
         }
 
-//        public bool NeedSceneCacheClear(UUID agentID, Scene scene)
-//        {
-//            if (!m_AgentRegions.ContainsKey(agentID))
-//            {
-//                // Since we can get here two ways, we need to scan
-//                // the scenes here. This is somewhat more expensive
-//                // but helps avoid a nasty bug
-//                //
-//
-//                foreach (Scene s in m_Scenelist)
-//                {
-//                    ScenePresence presence;
-//
-//                    if (s.TryGetScenePresence(agentID, out presence))
-//                    {
-//                        // If the agent is in this scene, then we
-//                        // are being called twice in a single
-//                        // teleport. This is wasteful of cycles
-//                        // but harmless due to this 2nd level check
-//                        //
-//                        // If the agent is found in another scene
-//                        // then the list wasn't current
-//                        //
-//                        // If the agent is totally unknown, then what
-//                        // are we even doing here??
-//                        //
-//                        if (s == scene)
-//                        {
-//                            //m_log.Debug("[INVTRANSFERMOD]: s == scene. Returning true in " + scene.RegionInfo.RegionName);
-//                            return true;
-//                        }
-//                        else
-//                        {
-//                            //m_log.Debug("[INVTRANSFERMOD]: s != scene. Returning false in " + scene.RegionInfo.RegionName);
-//                            return false;
-//                        }
-//                    }
-//                }
-//                //m_log.Debug("[INVTRANSFERMOD]: agent not in scene. Returning true in " + scene.RegionInfo.RegionName);
-//                return true;
-//            }
-//
-//            // The agent is left in current Scene, so we must be
-//            // going to another instance
-//            //
-//            if (m_AgentRegions[agentID] == scene)
-//            {
-//                //m_log.Debug("[INVTRANSFERMOD]: m_AgentRegions[agentID] == scene. Returning true in " + scene.RegionInfo.RegionName);
-//                m_AgentRegions.Remove(agentID);
-//                return true;
-//            }
-//
-//            // Another region has claimed the agent
-//            //
-//            //m_log.Debug("[INVTRANSFERMOD]: last resort. Returning false in " + scene.RegionInfo.RegionName);
-//            return false;
-//        }
-//
-//        public void ClientLoggedOut(UUID agentID, Scene scene)
-//        {
-//            if (m_AgentRegions.ContainsKey(agentID))
-//                m_AgentRegions.Remove(agentID);
-//        }
-
         /// <summary>
         ///
         /// </summary>
-        /// <param name="msg"></param>
-        private void OnGridInstantMessage(GridInstantMessage msg)
+        /// <param name="im"></param>
+        private void OnGridInstantMessage(GridInstantMessage im)
         {
+            // Check if it's a type of message that we should handle
+            if (!((im.dialog == (byte) InstantMessageDialog.InventoryOffered)
+                || (im.dialog == (byte) InstantMessageDialog.TaskInventoryOffered)
+                || (im.dialog == (byte) InstantMessageDialog.InventoryAccepted)
+                || (im.dialog == (byte) InstantMessageDialog.InventoryDeclined)
+                || (im.dialog == (byte) InstantMessageDialog.TaskInventoryDeclined)))
+                return;
+
+            m_log.DebugFormat(
+                "[INVENTORY TRANSFER]: {0} IM type received from grid. From={1} ({2}), To={3}",
+                (InstantMessageDialog)im.dialog, im.fromAgentID, im.fromAgentName, im.toAgentID);
+
             // Check if this is ours to handle
             //
-            Scene scene = FindClientScene(new UUID(msg.toAgentID));
+            Scene scene = FindClientScene(new UUID(im.toAgentID));
 
             if (scene == null)
                 return;
 
             // Find agent to deliver to
             //
-            ScenePresence user = scene.GetScenePresence(new UUID(msg.toAgentID));
+            ScenePresence user = scene.GetScenePresence(new UUID(im.toAgentID));
 
-            // Just forward to local handling
-            OnInstantMessage(user.ControllingClient, msg);
+            if (user != null)
+            {
+                user.ControllingClient.SendInstantMessage(im);
+
+                if (im.dialog == (byte)InstantMessageDialog.InventoryOffered)
+                {
+                    AssetType assetType = (AssetType)im.binaryBucket[0];
+                    UUID inventoryID = new UUID(im.binaryBucket, 1);
+                
+                    IInventoryService invService = scene.InventoryService;
+                    InventoryNodeBase node = null;
+                    if (AssetType.Folder == assetType)
+                    {
+                        InventoryFolderBase folder = new InventoryFolderBase(inventoryID, new UUID(im.toAgentID));
+                        node = invService.GetFolder(folder);
+                    }
+                    else
+                    {
+                        InventoryItemBase item = new InventoryItemBase(inventoryID, new UUID(im.toAgentID));
+                        node = invService.GetItem(item);
+                    }
 
+                    if (node != null)
+                        user.ControllingClient.SendBulkUpdateInventory(node);
+                }
+            }
         }
     }
 }
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/Tests/InventoryTransferModuleTests.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/Tests/InventoryTransferModuleTests.cs
new file mode 100644
index 0000000..7ddc396
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/Tests/InventoryTransferModuleTests.cs
@@ -0,0 +1,448 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net.Config;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Assets;
+using OpenSim.Framework;
+using OpenSim.Region.CoreModules.Avatar.Inventory.Transfer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer.Tests
+{
+    [TestFixture]
+    public class InventoryTransferModuleTests : OpenSimTestCase
+    {    
+        protected TestScene m_scene;       
+            
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Messaging");
+            config.Configs["Messaging"].Set("InventoryTransferModule", "InventoryTransferModule");
+
+            m_scene = new SceneHelpers().SetupScene();            
+            SceneHelpers.SetupSceneModules(m_scene, config, new InventoryTransferModule());
+        } 
+
+        [Test]
+        public void TestAcceptGivenItem()
+        {
+//            TestHelpers.EnableLogging();
+
+            UUID initialSessionId = TestHelpers.ParseTail(0x10);
+            UUID itemId = TestHelpers.ParseTail(0x100);
+            UUID assetId = TestHelpers.ParseTail(0x200);
+
+            UserAccount ua1 
+                = UserAccountHelpers.CreateUserWithInventory(m_scene, "User", "One", TestHelpers.ParseTail(0x1), "pw");
+            UserAccount ua2 
+                = UserAccountHelpers.CreateUserWithInventory(m_scene, "User", "Two", TestHelpers.ParseTail(0x2), "pw");
+
+            ScenePresence giverSp = SceneHelpers.AddScenePresence(m_scene, ua1);
+            TestClient giverClient = (TestClient)giverSp.ControllingClient;
+
+            ScenePresence receiverSp = SceneHelpers.AddScenePresence(m_scene, ua2);
+            TestClient receiverClient = (TestClient)receiverSp.ControllingClient;
+
+            // Create the object to test give
+            InventoryItemBase originalItem 
+                = UserInventoryHelpers.CreateInventoryItem(
+                    m_scene, "givenObj", itemId, assetId, giverSp.UUID, InventoryType.Object);
+
+            byte[] giveImBinaryBucket = new byte[17];
+            byte[] itemIdBytes = itemId.GetBytes();
+            Array.Copy(itemIdBytes, 0, giveImBinaryBucket, 1, itemIdBytes.Length);
+
+            GridInstantMessage giveIm 
+                = new GridInstantMessage(
+                    m_scene, 
+                    giverSp.UUID, 
+                    giverSp.Name, 
+                    receiverSp.UUID, 
+                    (byte)InstantMessageDialog.InventoryOffered,
+                    false,
+                    "inventory offered msg", 
+                    initialSessionId,
+                    false, 
+                    Vector3.Zero,
+                    giveImBinaryBucket,
+                    true);
+
+            giverClient.HandleImprovedInstantMessage(giveIm);
+
+            // These details might not all be correct.  
+            GridInstantMessage acceptIm 
+                = new GridInstantMessage(
+                    m_scene, 
+                    receiverSp.UUID, 
+                    receiverSp.Name, 
+                    giverSp.UUID, 
+                    (byte)InstantMessageDialog.InventoryAccepted, 
+                    false,
+                    "inventory accepted msg", 
+                    initialSessionId,
+                    false, 
+                    Vector3.Zero,
+                    null,
+                    true);
+
+            receiverClient.HandleImprovedInstantMessage(acceptIm);
+
+            // Test for item remaining in the giver's inventory (here we assume a copy item)
+            // TODO: Test no-copy items.
+            InventoryItemBase originalItemAfterGive
+                = UserInventoryHelpers.GetInventoryItem(m_scene.InventoryService, giverSp.UUID, "Objects/givenObj");
+
+            Assert.That(originalItemAfterGive, Is.Not.Null);
+            Assert.That(originalItemAfterGive.ID, Is.EqualTo(originalItem.ID));
+
+            // Test for item successfully making it into the receiver's inventory
+            InventoryItemBase receivedItem 
+                = UserInventoryHelpers.GetInventoryItem(m_scene.InventoryService, receiverSp.UUID, "Objects/givenObj");
+
+            Assert.That(receivedItem, Is.Not.Null);
+            Assert.That(receivedItem.ID, Is.Not.EqualTo(originalItem.ID));
+
+            // Test that on a delete, item still exists and is accessible for the giver.
+            m_scene.InventoryService.DeleteItems(receiverSp.UUID, new List<UUID>() { receivedItem.ID });
+
+            InventoryItemBase originalItemAfterDelete
+                = UserInventoryHelpers.GetInventoryItem(m_scene.InventoryService, giverSp.UUID, "Objects/givenObj");
+
+            Assert.That(originalItemAfterDelete, Is.Not.Null);
+
+            // TODO: Test scenario where giver deletes their item first.
+        }       
+
+        /// <summary>
+        /// Test user rejection of a given item.
+        /// </summary>
+        /// <remarks>
+        /// A rejected item still ends up in the user's trash folder.
+        /// </remarks>
+        [Test]
+        public void TestRejectGivenItem()
+        {
+//            TestHelpers.EnableLogging();
+
+            UUID initialSessionId = TestHelpers.ParseTail(0x10);
+            UUID itemId = TestHelpers.ParseTail(0x100);
+            UUID assetId = TestHelpers.ParseTail(0x200);
+
+            UserAccount ua1 
+                = UserAccountHelpers.CreateUserWithInventory(m_scene, "User", "One", TestHelpers.ParseTail(0x1), "pw");
+            UserAccount ua2 
+                = UserAccountHelpers.CreateUserWithInventory(m_scene, "User", "Two", TestHelpers.ParseTail(0x2), "pw");
+
+            ScenePresence giverSp = SceneHelpers.AddScenePresence(m_scene, ua1);
+            TestClient giverClient = (TestClient)giverSp.ControllingClient;
+
+            ScenePresence receiverSp = SceneHelpers.AddScenePresence(m_scene, ua2);
+            TestClient receiverClient = (TestClient)receiverSp.ControllingClient;
+
+            // Create the object to test give
+            InventoryItemBase originalItem 
+                = UserInventoryHelpers.CreateInventoryItem(
+                    m_scene, "givenObj", itemId, assetId, giverSp.UUID, InventoryType.Object);
+
+            GridInstantMessage receivedIm = null;
+            receiverClient.OnReceivedInstantMessage += im => receivedIm = im;
+
+            byte[] giveImBinaryBucket = new byte[17];
+            byte[] itemIdBytes = itemId.GetBytes();
+            Array.Copy(itemIdBytes, 0, giveImBinaryBucket, 1, itemIdBytes.Length);
+
+            GridInstantMessage giveIm 
+                = new GridInstantMessage(
+                    m_scene, 
+                    giverSp.UUID, 
+                    giverSp.Name, 
+                    receiverSp.UUID, 
+                    (byte)InstantMessageDialog.InventoryOffered,
+                    false,
+                    "inventory offered msg", 
+                    initialSessionId,
+                    false, 
+                    Vector3.Zero,
+                    giveImBinaryBucket,
+                    true);
+
+            giverClient.HandleImprovedInstantMessage(giveIm);
+
+            // These details might not all be correct.  
+            // Session ID is now the created item ID (!)
+            GridInstantMessage rejectIm 
+                = new GridInstantMessage(
+                    m_scene, 
+                    receiverSp.UUID, 
+                    receiverSp.Name, 
+                    giverSp.UUID, 
+                    (byte)InstantMessageDialog.InventoryDeclined, 
+                    false,
+                    "inventory declined msg", 
+                    new UUID(receivedIm.imSessionID),
+                    false, 
+                    Vector3.Zero,
+                    null,
+                    true);
+
+            receiverClient.HandleImprovedInstantMessage(rejectIm);
+
+            // Test for item remaining in the giver's inventory (here we assume a copy item)
+            // TODO: Test no-copy items.
+            InventoryItemBase originalItemAfterGive
+                = UserInventoryHelpers.GetInventoryItem(m_scene.InventoryService, giverSp.UUID, "Objects/givenObj");
+
+            Assert.That(originalItemAfterGive, Is.Not.Null);
+            Assert.That(originalItemAfterGive.ID, Is.EqualTo(originalItem.ID));
+
+            // Test for item successfully making it into the receiver's inventory
+            InventoryItemBase receivedItem 
+                = UserInventoryHelpers.GetInventoryItem(m_scene.InventoryService, receiverSp.UUID, "Trash/givenObj");
+
+            InventoryFolderBase trashFolder
+                = m_scene.InventoryService.GetFolderForType(receiverSp.UUID, FolderType.Trash);
+
+            Assert.That(receivedItem, Is.Not.Null);
+            Assert.That(receivedItem.ID, Is.Not.EqualTo(originalItem.ID));
+            Assert.That(receivedItem.Folder, Is.EqualTo(trashFolder.ID));
+
+            // Test that on a delete, item still exists and is accessible for the giver.
+            m_scene.InventoryService.PurgeFolder(trashFolder);
+
+            InventoryItemBase originalItemAfterDelete
+                = UserInventoryHelpers.GetInventoryItem(m_scene.InventoryService, giverSp.UUID, "Objects/givenObj");
+
+            Assert.That(originalItemAfterDelete, Is.Not.Null);
+        }  
+
+        [Test]
+        public void TestAcceptGivenFolder()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            UUID initialSessionId = TestHelpers.ParseTail(0x10);
+            UUID folderId = TestHelpers.ParseTail(0x100);
+
+            UserAccount ua1 
+                = UserAccountHelpers.CreateUserWithInventory(m_scene, "User", "One", TestHelpers.ParseTail(0x1), "pw");
+            UserAccount ua2 
+                = UserAccountHelpers.CreateUserWithInventory(m_scene, "User", "Two", TestHelpers.ParseTail(0x2), "pw");
+
+            ScenePresence giverSp = SceneHelpers.AddScenePresence(m_scene, ua1);
+            TestClient giverClient = (TestClient)giverSp.ControllingClient;
+
+            ScenePresence receiverSp = SceneHelpers.AddScenePresence(m_scene, ua2);
+            TestClient receiverClient = (TestClient)receiverSp.ControllingClient;
+
+            InventoryFolderBase originalFolder 
+                = UserInventoryHelpers.CreateInventoryFolder(
+                    m_scene.InventoryService, giverSp.UUID, folderId, "f1", true);
+
+            byte[] giveImBinaryBucket = new byte[17];
+            giveImBinaryBucket[0] = (byte)AssetType.Folder;
+            byte[] itemIdBytes = folderId.GetBytes();
+            Array.Copy(itemIdBytes, 0, giveImBinaryBucket, 1, itemIdBytes.Length);
+
+            GridInstantMessage giveIm 
+                = new GridInstantMessage(
+                    m_scene, 
+                    giverSp.UUID, 
+                    giverSp.Name, 
+                    receiverSp.UUID, 
+                    (byte)InstantMessageDialog.InventoryOffered,
+                    false,
+                    "inventory offered msg", 
+                    initialSessionId,
+                    false, 
+                    Vector3.Zero,
+                    giveImBinaryBucket,
+                    true);
+
+            giverClient.HandleImprovedInstantMessage(giveIm);
+
+            // These details might not all be correct.  
+            GridInstantMessage acceptIm 
+                = new GridInstantMessage(
+                    m_scene, 
+                    receiverSp.UUID, 
+                    receiverSp.Name, 
+                    giverSp.UUID, 
+                    (byte)InstantMessageDialog.InventoryAccepted, 
+                    false,
+                    "inventory accepted msg", 
+                    initialSessionId,
+                    false, 
+                    Vector3.Zero,
+                    null,
+                    true);
+
+            receiverClient.HandleImprovedInstantMessage(acceptIm);
+
+            // Test for item remaining in the giver's inventory (here we assume a copy item)
+            // TODO: Test no-copy items.
+            InventoryFolderBase originalFolderAfterGive
+                = UserInventoryHelpers.GetInventoryFolder(m_scene.InventoryService, giverSp.UUID, "f1");
+
+            Assert.That(originalFolderAfterGive, Is.Not.Null);
+            Assert.That(originalFolderAfterGive.ID, Is.EqualTo(originalFolder.ID));
+
+            // Test for item successfully making it into the receiver's inventory
+            InventoryFolderBase receivedFolder 
+                = UserInventoryHelpers.GetInventoryFolder(m_scene.InventoryService, receiverSp.UUID, "f1");
+
+            Assert.That(receivedFolder, Is.Not.Null);
+            Assert.That(receivedFolder.ID, Is.Not.EqualTo(originalFolder.ID));
+
+            // Test that on a delete, item still exists and is accessible for the giver.
+            m_scene.InventoryService.DeleteFolders(receiverSp.UUID, new List<UUID>() { receivedFolder.ID });
+
+            InventoryFolderBase originalFolderAfterDelete
+                = UserInventoryHelpers.GetInventoryFolder(m_scene.InventoryService, giverSp.UUID, "f1");
+
+            Assert.That(originalFolderAfterDelete, Is.Not.Null);
+
+            // TODO: Test scenario where giver deletes their item first.
+        }       
+
+        /// <summary>
+        /// Test user rejection of a given item.
+        /// </summary>
+        /// <remarks>
+        /// A rejected item still ends up in the user's trash folder.
+        /// </remarks>
+        [Test]
+        public void TestRejectGivenFolder()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            UUID initialSessionId = TestHelpers.ParseTail(0x10);
+            UUID folderId = TestHelpers.ParseTail(0x100);
+
+            UserAccount ua1 
+                = UserAccountHelpers.CreateUserWithInventory(m_scene, "User", "One", TestHelpers.ParseTail(0x1), "pw");
+            UserAccount ua2 
+                = UserAccountHelpers.CreateUserWithInventory(m_scene, "User", "Two", TestHelpers.ParseTail(0x2), "pw");
+
+            ScenePresence giverSp = SceneHelpers.AddScenePresence(m_scene, ua1);
+            TestClient giverClient = (TestClient)giverSp.ControllingClient;
+
+            ScenePresence receiverSp = SceneHelpers.AddScenePresence(m_scene, ua2);
+            TestClient receiverClient = (TestClient)receiverSp.ControllingClient;
+
+            // Create the folder to test give
+            InventoryFolderBase originalFolder 
+                = UserInventoryHelpers.CreateInventoryFolder(
+                    m_scene.InventoryService, giverSp.UUID, folderId, "f1", true);
+
+            GridInstantMessage receivedIm = null;
+            receiverClient.OnReceivedInstantMessage += im => receivedIm = im;
+
+            byte[] giveImBinaryBucket = new byte[17];
+            giveImBinaryBucket[0] = (byte)AssetType.Folder;
+            byte[] itemIdBytes = folderId.GetBytes();
+            Array.Copy(itemIdBytes, 0, giveImBinaryBucket, 1, itemIdBytes.Length);
+
+            GridInstantMessage giveIm 
+                = new GridInstantMessage(
+                    m_scene, 
+                    giverSp.UUID, 
+                    giverSp.Name, 
+                    receiverSp.UUID, 
+                    (byte)InstantMessageDialog.InventoryOffered,
+                    false,
+                    "inventory offered msg", 
+                    initialSessionId,
+                    false, 
+                    Vector3.Zero,
+                    giveImBinaryBucket,
+                    true);
+
+            giverClient.HandleImprovedInstantMessage(giveIm);
+
+            // These details might not all be correct.  
+            // Session ID is now the created item ID (!)
+            GridInstantMessage rejectIm 
+                = new GridInstantMessage(
+                    m_scene, 
+                    receiverSp.UUID, 
+                    receiverSp.Name, 
+                    giverSp.UUID, 
+                    (byte)InstantMessageDialog.InventoryDeclined, 
+                    false,
+                    "inventory declined msg", 
+                    new UUID(receivedIm.imSessionID),
+                    false, 
+                    Vector3.Zero,
+                    null,
+                    true);
+
+            receiverClient.HandleImprovedInstantMessage(rejectIm);
+
+            // Test for item remaining in the giver's inventory (here we assume a copy item)
+            // TODO: Test no-copy items.
+            InventoryFolderBase originalFolderAfterGive
+                = UserInventoryHelpers.GetInventoryFolder(m_scene.InventoryService, giverSp.UUID, "f1");
+
+            Assert.That(originalFolderAfterGive, Is.Not.Null);
+            Assert.That(originalFolderAfterGive.ID, Is.EqualTo(originalFolder.ID));
+
+            // Test for folder successfully making it into the receiver's inventory
+            InventoryFolderBase receivedFolder 
+                = UserInventoryHelpers.GetInventoryFolder(m_scene.InventoryService, receiverSp.UUID, "Trash/f1");
+
+            InventoryFolderBase trashFolder
+                = m_scene.InventoryService.GetFolderForType(receiverSp.UUID, FolderType.Trash);
+
+            Assert.That(receivedFolder, Is.Not.Null);
+            Assert.That(receivedFolder.ID, Is.Not.EqualTo(originalFolder.ID));
+            Assert.That(receivedFolder.ParentID, Is.EqualTo(trashFolder.ID));
+
+            // Test that on a delete, item still exists and is accessible for the giver.
+            m_scene.InventoryService.PurgeFolder(trashFolder);
+
+            InventoryFolderBase originalFolderAfterDelete
+                = UserInventoryHelpers.GetInventoryFolder(m_scene.InventoryService, giverSp.UUID, "f1");
+
+            Assert.That(originalFolderAfterDelete, Is.Not.Null);
+        }  
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Avatar/Lure/HGLureModule.cs b/OpenSim/Region/CoreModules/Avatar/Lure/HGLureModule.cs
index 232a4fe..24286a4 100644
--- a/OpenSim/Region/CoreModules/Avatar/Lure/HGLureModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Lure/HGLureModule.cs
@@ -65,7 +65,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Lure
                 {
                     m_Enabled = true;
 
-                    m_ThisGridURL = config.Configs["Messaging"].GetString("Gatekeeper", string.Empty);
+                    m_ThisGridURL = Util.GetConfigVarFromSections<string>(config, "GatekeeperURI", 
+                        new string[] { "Startup", "Hypergrid", "Messaging" }, String.Empty);
+                    // Legacy. Remove soon!
+                    m_ThisGridURL = config.Configs["Messaging"].GetString("Gatekeeper", m_ThisGridURL);
                     m_log.DebugFormat("[LURE MODULE]: {0} enabled", Name);
                 }
             }
@@ -151,7 +154,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Lure
 
         void OnIncomingInstantMessage(GridInstantMessage im)
         {
-            if (im.dialog == (byte)InstantMessageDialog.RequestTeleport)
+            if (im.dialog == (byte)InstantMessageDialog.RequestTeleport 
+                || im.dialog == (byte)InstantMessageDialog.GodLikeRequestTeleport)
             {
                 UUID sessionID = new UUID(im.imSessionID);
 
@@ -235,16 +239,29 @@ namespace OpenSim.Region.CoreModules.Avatar.Lure
                         GatekeeperServiceConnector gConn = new GatekeeperServiceConnector();
                         GridRegion gatekeeper = new GridRegion();
                         gatekeeper.ServerURI = url;
-                        GridRegion finalDestination = gConn.GetHyperlinkRegion(gatekeeper, new UUID(im.RegionID));
+                        string homeURI = scene.GetAgentHomeURI(client.AgentId);
+
+                        string message;
+                        GridRegion finalDestination = gConn.GetHyperlinkRegion(gatekeeper, new UUID(im.RegionID), client.AgentId, homeURI, out message);
                         if (finalDestination != null)
                         {
                             ScenePresence sp = scene.GetScenePresence(client.AgentId);
                             IEntityTransferModule transferMod = scene.RequestModuleInterface<IEntityTransferModule>();
 
                             if (transferMod != null && sp != null)
+                            {
+                                if (message != null)
+                                    sp.ControllingClient.SendAgentAlertMessage(message, true);
+
                                 transferMod.DoTeleport(
                                     sp, gatekeeper, finalDestination, im.Position + new Vector3(0.5f, 0.5f, 0f),
                                     Vector3.UnitX, teleportflags);
+                            }
+                        }
+                        else
+                        {
+                            m_log.InfoFormat("[HG LURE MODULE]: Lure failed: {0}", message);
+                            client.SendAgentAlertMessage(message, true);
                         }
                     }
                 }
diff --git a/OpenSim/Region/CoreModules/Avatar/Lure/LureModule.cs b/OpenSim/Region/CoreModules/Avatar/Lure/LureModule.cs
index e4b0cfa..465ffbc 100644
--- a/OpenSim/Region/CoreModules/Avatar/Lure/LureModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Lure/LureModule.cs
@@ -165,7 +165,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Lure
                     (uint)presence.AbsolutePosition.Y,
                     (uint)Math.Ceiling(presence.AbsolutePosition.Z));
 
-            m_log.DebugFormat("TP invite with message {0}", message);
+            m_log.DebugFormat("[LURE MODULE]: TP invite with message {0}, type {1}", message, lureType);
 
             GridInstantMessage m = new GridInstantMessage(scene, client.AgentId,
                     client.FirstName+" "+client.LastName, targetid,
diff --git a/OpenSim/Region/CoreModules/Avatar/Profile/BasicProfileModule.cs b/OpenSim/Region/CoreModules/Avatar/Profile/BasicProfileModule.cs
index bf24030..2bb24ae 100644
--- a/OpenSim/Region/CoreModules/Avatar/Profile/BasicProfileModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Profile/BasicProfileModule.cs
@@ -57,6 +57,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Profile
 
         public void Initialise(IConfigSource config)
         {
+            if(config.Configs["UserProfiles"] != null)
+                return;
+
             m_log.DebugFormat("[PROFILE MODULE]: Basic Profile Module enabled");
             m_Enabled = true;
         }
diff --git a/OpenSim/Region/CoreModules/Avatar/UserProfiles/UserProfileModule.cs b/OpenSim/Region/CoreModules/Avatar/UserProfiles/UserProfileModule.cs
new file mode 100644
index 0000000..c20369c
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/UserProfiles/UserProfileModule.cs
@@ -0,0 +1,1406 @@
+/*
+ * 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.IO;
+using System.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Net;
+using System.Net.Sockets;
+using System.Reflection;
+using System.Xml;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Mono.Addins;
+using OpenSim.Services.Connectors.Hypergrid;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Services.UserProfilesService;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using Microsoft.CSharp;
+
+namespace OpenSim.Region.CoreModules.Avatar.UserProfiles
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "UserProfilesModule")]
+    public class UserProfileModule : IProfileModule, INonSharedRegionModule
+    {
+        /// <summary>
+        /// Logging
+        /// </summary>
+        static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        // The pair of Dictionaries are used to handle the switching of classified ads
+        // by maintaining a cache of classified id to creator id mappings and an interest
+        // count. The entries are removed when the interest count reaches 0.
+        Dictionary<UUID, UUID> m_classifiedCache = new Dictionary<UUID, UUID>();
+        Dictionary<UUID, int> m_classifiedInterest = new Dictionary<UUID, int>();
+
+        private JsonRpcRequestManager rpc = new JsonRpcRequestManager();
+
+        public Scene Scene
+        {
+            get; private set;
+        }
+
+        /// <summary>
+        /// Gets or sets the ConfigSource.
+        /// </summary>
+        /// <value>
+        /// The configuration
+        /// </value>
+        public IConfigSource Config 
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the URI to the profile server.
+        /// </summary>
+        /// <value>
+        /// The profile server URI.
+        /// </value>
+        public string ProfileServerUri 
+        {
+            get;
+            set;
+        }
+
+        IProfileModule ProfileModule
+        {
+            get; set;
+        }
+
+        IUserManagement UserManagementModule
+        {
+            get; set;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this
+        /// <see cref="OpenSim.Region.Coremodules.UserProfiles.UserProfileModule"/> is enabled.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if enabled; otherwise, <c>false</c>.
+        /// </value>
+        public bool Enabled 
+        {
+            get;
+            set;
+        }
+
+        public string MyGatekeeper 
+        {
+            get; private set;
+        }
+
+
+        #region IRegionModuleBase implementation
+        /// <summary>
+        ///  This is called to initialize the region module. For shared modules, this is called exactly once, after
+        /// creating the single (shared) instance. For non-shared modules, this is called once on each instance, after
+        /// the instace for the region has been created. 
+        /// </summary>
+        /// <param name='source'>
+        /// Source.
+        /// </param>
+        public void Initialise(IConfigSource source)
+        {
+            Config = source;
+            ReplaceableInterface = typeof(IProfileModule);
+
+            IConfig profileConfig = Config.Configs["UserProfiles"];
+
+            if (profileConfig == null)
+            {
+                m_log.Debug("[PROFILES]: UserProfiles disabled, no configuration");
+                Enabled = false;
+                return;
+            }
+
+            // If we find ProfileURL then we configure for FULL support
+            // else we setup for BASIC support
+            ProfileServerUri = profileConfig.GetString("ProfileServiceURL", "");
+            if (ProfileServerUri == "")
+            {
+                Enabled = false;
+                return;
+            }
+                
+            m_log.Debug("[PROFILES]: Full Profiles Enabled");
+            ReplaceableInterface = null;
+            Enabled = true;
+
+            MyGatekeeper = Util.GetConfigVarFromSections<string>(source, "GatekeeperURI",
+                new string[] { "Startup", "Hypergrid", "UserProfiles" }, String.Empty);
+        }
+
+        /// <summary>
+        /// Adds the region.
+        /// </summary>
+        /// <param name='scene'>
+        /// Scene.
+        /// </param>
+        public void AddRegion(Scene scene)
+        {
+            if(!Enabled)
+                return;
+
+            Scene = scene;
+            Scene.RegisterModuleInterface<IProfileModule>(this);
+            Scene.EventManager.OnNewClient += OnNewClient;
+            Scene.EventManager.OnMakeRootAgent += HandleOnMakeRootAgent;
+
+            UserManagementModule = Scene.RequestModuleInterface<IUserManagement>();
+        }
+
+        void HandleOnMakeRootAgent (ScenePresence obj)
+        {
+            if(obj.PresenceType == PresenceType.Npc)
+                return;
+
+            Util.FireAndForget(delegate
+            {
+                GetImageAssets(((IScenePresence)obj).UUID);
+            }, null, "UserProfileModule.GetImageAssets");
+        }
+
+        /// <summary>
+        /// Removes the region.
+        /// </summary>
+        /// <param name='scene'>
+        /// Scene.
+        /// </param>
+        public void RemoveRegion(Scene scene)
+        {
+            if(!Enabled)
+                return;
+        }
+
+        /// <summary>
+        ///  This will be called once for every scene loaded. In a shared module this will be multiple times in one
+        /// instance, while a nonshared module instance will only be called once. This method is called after AddRegion
+        /// has been called in all modules for that scene, providing an opportunity to request another module's
+        /// interface, or hook an event from another module. 
+        /// </summary>
+        /// <param name='scene'>
+        /// Scene.
+        /// </param>
+        public void RegionLoaded(Scene scene)
+        {
+            if(!Enabled)
+                return;
+        }
+
+        /// <summary>
+        ///  If this returns non-null, it is the type of an interface that this module intends to register. This will
+        /// cause the loader to defer loading of this module until all other modules have been loaded. If no other
+        /// module has registered the interface by then, this module will be activated, else it will remain inactive,
+        /// letting the other module take over. This should return non-null ONLY in modules that are intended to be
+        /// easily replaceable, e.g. stub implementations that the developer expects to be replaced by third party
+        /// provided modules. 
+        /// </summary>
+        /// <value>
+        /// The replaceable interface.
+        /// </value>
+        public Type ReplaceableInterface
+        {
+            get; private set;
+        }
+
+        /// <summary>
+        /// Called as the instance is closed.
+        /// </summary>
+        public void Close()
+        {
+        }
+
+        /// <value>
+        ///  The name of the module 
+        /// </value>
+        /// <summary>
+        /// Gets the module name.
+        /// </summary>
+        public string Name
+        {
+            get { return "UserProfileModule"; }
+        }
+        #endregion IRegionModuleBase implementation
+
+        #region Region Event Handlers
+        /// <summary>
+        /// Raises the new client event.
+        /// </summary>
+        /// <param name='client'>
+        /// Client.
+        /// </param>
+        void OnNewClient(IClientAPI client)
+        {
+            //Profile
+            client.OnRequestAvatarProperties += RequestAvatarProperties;
+            client.OnUpdateAvatarProperties += AvatarPropertiesUpdate;
+            client.OnAvatarInterestUpdate += AvatarInterestsUpdate;
+
+            // Classifieds
+            client.AddGenericPacketHandler("avatarclassifiedsrequest", ClassifiedsRequest);
+            client.OnClassifiedInfoUpdate += ClassifiedInfoUpdate;
+            client.OnClassifiedInfoRequest += ClassifiedInfoRequest;
+            client.OnClassifiedDelete += ClassifiedDelete;
+
+            // Picks
+            client.AddGenericPacketHandler("avatarpicksrequest", PicksRequest);
+            client.AddGenericPacketHandler("pickinforequest", PickInfoRequest);
+            client.OnPickInfoUpdate += PickInfoUpdate;
+            client.OnPickDelete += PickDelete;
+
+            // Notes
+            client.AddGenericPacketHandler("avatarnotesrequest", NotesRequest);
+            client.OnAvatarNotesUpdate += NotesUpdate;
+
+            // Preferences
+            client.OnUserInfoRequest += UserPreferencesRequest;
+            client.OnUpdateUserInfo += UpdateUserPreferences;
+        }
+        #endregion Region Event Handlers
+
+        #region Classified
+        ///
+        /// <summary>
+        /// Handles the avatar classifieds request.
+        /// </summary>
+        /// <param name='sender'>
+        /// Sender.
+        /// </param>
+        /// <param name='method'>
+        /// Method.
+        /// </param>
+        /// <param name='args'>
+        /// Arguments.
+        /// </param>
+        public void ClassifiedsRequest(Object sender, string method, List<String> args)
+        {
+            if (!(sender is IClientAPI))
+                return;
+
+            IClientAPI remoteClient = (IClientAPI)sender;
+
+            UUID targetID;
+            UUID.TryParse(args[0], out targetID);
+
+            // Can't handle NPC yet...
+            ScenePresence p = FindPresence(targetID);
+
+            if (null != p)
+            {
+                if (p.PresenceType == PresenceType.Npc)
+                    return;
+            }
+
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(targetID, out serverURI);
+            UUID creatorId = UUID.Zero;
+            Dictionary<UUID, string> classifieds = new Dictionary<UUID, string>();
+
+            OSDMap parameters= new OSDMap();
+            UUID.TryParse(args[0], out creatorId);
+            parameters.Add("creatorId", OSD.FromUUID(creatorId));
+            OSD Params = (OSD)parameters;
+            if(!rpc.JsonRpcRequest(ref Params, "avatarclassifiedsrequest", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAvatarClassifiedReply(new UUID(args[0]), classifieds);
+                return;
+            }
+
+            parameters = (OSDMap)Params;
+
+            OSDArray list = (OSDArray)parameters["result"];
+
+
+            foreach(OSD map in list)
+            {
+                OSDMap m = (OSDMap)map;
+                UUID cid = m["classifieduuid"].AsUUID();
+                string name = m["name"].AsString();
+
+                classifieds[cid] = name;
+
+                lock (m_classifiedCache)
+                {
+                    if (!m_classifiedCache.ContainsKey(cid))
+                    {
+                        m_classifiedCache.Add(cid,creatorId);
+                        m_classifiedInterest.Add(cid, 0);
+                    }
+
+                    m_classifiedInterest[cid]++;
+                }
+            }
+
+            remoteClient.SendAvatarClassifiedReply(new UUID(args[0]), classifieds);
+        }
+
+        public void ClassifiedInfoRequest(UUID queryClassifiedID, IClientAPI remoteClient)
+        {    
+            UUID target = remoteClient.AgentId;
+            UserClassifiedAdd ad = new UserClassifiedAdd();
+            ad.ClassifiedId = queryClassifiedID;
+
+            lock (m_classifiedCache)
+            {
+                if (m_classifiedCache.ContainsKey(queryClassifiedID))
+                {   
+                    target = m_classifiedCache[queryClassifiedID];
+
+                    m_classifiedInterest[queryClassifiedID] --;
+
+                    if (m_classifiedInterest[queryClassifiedID] == 0)
+                    {
+                        m_classifiedInterest.Remove(queryClassifiedID);
+                        m_classifiedCache.Remove(queryClassifiedID);
+                    }
+                }
+            }
+            
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(target, out serverURI);
+
+            object Ad = (object)ad;
+            if(!rpc.JsonRpcRequest(ref Ad, "classifieds_info_query", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAgentAlertMessage(
+                        "Error getting classified info", false);
+                return;
+            }
+            ad = (UserClassifiedAdd) Ad;
+
+            if(ad.CreatorId == UUID.Zero)
+                return;
+
+            Vector3 globalPos = new Vector3();
+            Vector3.TryParse(ad.GlobalPos, out globalPos);
+
+            remoteClient.SendClassifiedInfoReply(ad.ClassifiedId, ad.CreatorId, (uint)ad.CreationDate, (uint)ad.ExpirationDate,
+                                                 (uint)ad.Category, ad.Name, ad.Description, ad.ParcelId, (uint)ad.ParentEstate,
+                                                 ad.SnapshotId, ad.SimName, globalPos, ad.ParcelName, ad.Flags, ad.Price);
+
+        }
+
+        /// <summary>
+        /// Classifieds info update.
+        /// </summary>
+        /// <param name='queryclassifiedID'>
+        /// Queryclassified I.
+        /// </param>
+        /// <param name='queryCategory'>
+        /// Query category.
+        /// </param>
+        /// <param name='queryName'>
+        /// Query name.
+        /// </param>
+        /// <param name='queryDescription'>
+        /// Query description.
+        /// </param>
+        /// <param name='queryParcelID'>
+        /// Query parcel I.
+        /// </param>
+        /// <param name='queryParentEstate'>
+        /// Query parent estate.
+        /// </param>
+        /// <param name='querySnapshotID'>
+        /// Query snapshot I.
+        /// </param>
+        /// <param name='queryGlobalPos'>
+        /// Query global position.
+        /// </param>
+        /// <param name='queryclassifiedFlags'>
+        /// Queryclassified flags.
+        /// </param>
+        /// <param name='queryclassifiedPrice'>
+        /// Queryclassified price.
+        /// </param>
+        /// <param name='remoteClient'>
+        /// Remote client.
+        /// </param>
+        public void ClassifiedInfoUpdate(UUID queryclassifiedID, uint queryCategory, string queryName, string queryDescription, UUID queryParcelID,
+                                         uint queryParentEstate, UUID querySnapshotID, Vector3 queryGlobalPos, byte queryclassifiedFlags,
+                                         int queryclassifiedPrice, IClientAPI remoteClient)
+        {
+            Scene s = (Scene)remoteClient.Scene;
+            IMoneyModule money = s.RequestModuleInterface<IMoneyModule>();
+
+            if (money != null)
+            {
+                if (!money.AmountCovered(remoteClient.AgentId, queryclassifiedPrice))
+                {
+                    remoteClient.SendAgentAlertMessage("You do not have enough money to create requested classified.", false);
+                    return;
+                }
+                money.ApplyCharge(remoteClient.AgentId, queryclassifiedPrice, MoneyTransactionType.ClassifiedCharge);
+            }
+
+            UserClassifiedAdd ad = new UserClassifiedAdd();
+
+            Vector3 pos = remoteClient.SceneAgent.AbsolutePosition;
+            ILandObject land = s.LandChannel.GetLandObject(pos.X, pos.Y);
+            ScenePresence p = FindPresence(remoteClient.AgentId);
+            
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+
+            if (land == null)
+            {
+                ad.ParcelName = string.Empty;
+            }
+            else
+            {
+                ad.ParcelName = land.LandData.Name;
+            }
+
+            ad.CreatorId = remoteClient.AgentId;
+            ad.ClassifiedId = queryclassifiedID;
+            ad.Category = Convert.ToInt32(queryCategory);
+            ad.Name = queryName;
+            ad.Description = queryDescription;
+            ad.ParentEstate = Convert.ToInt32(queryParentEstate);
+            ad.SnapshotId = querySnapshotID;
+            ad.SimName = remoteClient.Scene.RegionInfo.RegionName;
+            ad.GlobalPos = queryGlobalPos.ToString ();
+            ad.Flags = queryclassifiedFlags;
+            ad.Price = queryclassifiedPrice;
+            ad.ParcelId = p.currentParcelUUID;
+
+            object Ad = ad;
+
+            OSD.SerializeMembers(Ad);
+
+            if(!rpc.JsonRpcRequest(ref Ad, "classified_update", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAgentAlertMessage(
+                        "Error updating classified", false);
+                return;
+            }
+        }
+
+        /// <summary>
+        /// Classifieds delete.
+        /// </summary>
+        /// <param name='queryClassifiedID'>
+        /// Query classified I.
+        /// </param>
+        /// <param name='remoteClient'>
+        /// Remote client.
+        /// </param>
+        public void ClassifiedDelete(UUID queryClassifiedID, IClientAPI remoteClient)
+        {
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+
+            UUID classifiedId;
+            OSDMap parameters= new OSDMap();
+            UUID.TryParse(queryClassifiedID.ToString(), out classifiedId);
+            parameters.Add("classifiedId", OSD.FromUUID(classifiedId));
+            OSD Params = (OSD)parameters;
+            if(!rpc.JsonRpcRequest(ref Params, "classified_delete", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAgentAlertMessage(
+                        "Error classified delete", false);
+                return;
+            }
+
+            parameters = (OSDMap)Params;
+        }
+        #endregion Classified
+
+        #region Picks
+        /// <summary>
+        /// Handles the avatar picks request.
+        /// </summary>
+        /// <param name='sender'>
+        /// Sender.
+        /// </param>
+        /// <param name='method'>
+        /// Method.
+        /// </param>
+        /// <param name='args'>
+        /// Arguments.
+        /// </param>
+        public void PicksRequest(Object sender, string method, List<String> args)
+        {
+            if (!(sender is IClientAPI))
+                return;
+
+            IClientAPI remoteClient = (IClientAPI)sender;
+
+            UUID targetId;
+            UUID.TryParse(args[0], out targetId);
+
+            // Can't handle NPC yet...
+            ScenePresence p = FindPresence(targetId);
+
+            if (null != p)
+            {
+                if (p.PresenceType == PresenceType.Npc)
+                    return;
+            }
+
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(targetId, out serverURI);
+            
+            Dictionary<UUID, string> picks = new Dictionary<UUID, string>();
+
+            OSDMap parameters= new OSDMap();
+            parameters.Add("creatorId", OSD.FromUUID(targetId));
+            OSD Params = (OSD)parameters;
+            if(!rpc.JsonRpcRequest(ref Params, "avatarpicksrequest", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAvatarPicksReply(new UUID(args[0]), picks);
+                return;
+            }
+
+            parameters = (OSDMap)Params;
+
+            OSDArray list = (OSDArray)parameters["result"];
+
+            foreach(OSD map in list)
+            {
+                OSDMap m = (OSDMap)map;
+                UUID cid = m["pickuuid"].AsUUID();
+                string name = m["name"].AsString();
+                
+                m_log.DebugFormat("[PROFILES]: PicksRequest {0}", name);
+
+                picks[cid] = name;
+            }
+            remoteClient.SendAvatarPicksReply(new UUID(args[0]), picks);
+        }
+
+        /// <summary>
+        /// Handles the pick info request.
+        /// </summary>
+        /// <param name='sender'>
+        /// Sender.
+        /// </param>
+        /// <param name='method'>
+        /// Method.
+        /// </param>
+        /// <param name='args'>
+        /// Arguments.
+        /// </param>
+        public void PickInfoRequest(Object sender, string method, List<String> args)
+        {
+            if (!(sender is IClientAPI))
+                return;
+
+            UUID targetID;
+            UUID.TryParse (args [0], out targetID);
+            string serverURI = string.Empty;
+            GetUserProfileServerURI (targetID, out serverURI);
+
+            string theirGatekeeperURI;
+            GetUserGatekeeperURI (targetID, out theirGatekeeperURI);
+
+            IClientAPI remoteClient = (IClientAPI)sender;
+
+            UserProfilePick pick = new UserProfilePick ();
+            UUID.TryParse (args [0], out pick.CreatorId);
+            UUID.TryParse (args [1], out pick.PickId);
+
+                
+            object Pick = (object)pick;
+            if (!rpc.JsonRpcRequest (ref Pick, "pickinforequest", serverURI, UUID.Random ().ToString ())) {
+                remoteClient.SendAgentAlertMessage (
+                        "Error selecting pick", false);
+                return;
+            }
+            pick = (UserProfilePick)Pick;
+            
+            Vector3 globalPos = new Vector3(Vector3.Zero);
+            
+            // Smoke and mirrors
+            if (pick.Gatekeeper == MyGatekeeper) 
+            {
+                Vector3.TryParse(pick.GlobalPos,out globalPos);
+            } 
+            else 
+            {
+                // Setup the illusion
+                string region = string.Format("{0} {1}",pick.Gatekeeper,pick.SimName);
+                GridRegion target = Scene.GridService.GetRegionByName(Scene.RegionInfo.ScopeID, region);
+
+                if(target == null)
+                {
+                    // This is a dead or unreachable region
+                }
+                else
+                {
+                    // Work our slight of hand
+                    int x = target.RegionLocX;
+                    int y = target.RegionLocY;
+
+                    dynamic synthX = globalPos.X - (globalPos.X/Constants.RegionSize) * Constants.RegionSize;
+                    synthX += x;
+                    globalPos.X = synthX;
+
+                    dynamic synthY = globalPos.Y - (globalPos.Y/Constants.RegionSize) * Constants.RegionSize;
+                    synthY += y;
+                    globalPos.Y = synthY;
+                }
+            }
+
+            m_log.DebugFormat("[PROFILES]: PickInfoRequest: {0} : {1}", pick.Name.ToString(), pick.SnapshotId.ToString());
+
+            // Pull the rabbit out of the hat
+            remoteClient.SendPickInfoReply(pick.PickId,pick.CreatorId,pick.TopPick,pick.ParcelId,pick.Name,
+                                           pick.Desc,pick.SnapshotId,pick.ParcelName,pick.OriginalName,pick.SimName,
+                                           globalPos,pick.SortOrder,pick.Enabled);
+        }
+
+        /// <summary>
+        /// Updates the userpicks
+        /// </summary>
+        /// <param name='remoteClient'>
+        /// Remote client.
+        /// </param>
+        /// <param name='pickID'>
+        /// Pick I.
+        /// </param>
+        /// <param name='creatorID'>
+        /// the creator of the pick
+        /// </param>
+        /// <param name='topPick'>
+        /// Top pick.
+        /// </param>
+        /// <param name='name'>
+        /// Name.
+        /// </param>
+        /// <param name='desc'>
+        /// Desc.
+        /// </param>
+        /// <param name='snapshotID'>
+        /// Snapshot I.
+        /// </param>
+        /// <param name='sortOrder'>
+        /// Sort order.
+        /// </param>
+        /// <param name='enabled'>
+        /// Enabled.
+        /// </param>
+        public void PickInfoUpdate(IClientAPI remoteClient, UUID pickID, UUID creatorID, bool topPick, string name, string desc, UUID snapshotID, int sortOrder, bool enabled)
+        {        
+            //TODO: See how this works with NPC, May need to test
+            m_log.DebugFormat("[PROFILES]: Start PickInfoUpdate Name: {0} PickId: {1} SnapshotId: {2}", name, pickID.ToString(), snapshotID.ToString());
+
+            UserProfilePick pick = new UserProfilePick();
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+            ScenePresence p = FindPresence(remoteClient.AgentId);
+
+            Vector3 avaPos = p.AbsolutePosition;
+            // Getting the global position for the Avatar
+            Vector3 posGlobal = new Vector3(remoteClient.Scene.RegionInfo.WorldLocX + avaPos.X,
+                                            remoteClient.Scene.RegionInfo.WorldLocY + avaPos.Y,
+                                            avaPos.Z);
+
+            string  landParcelName  = "My Parcel";
+            UUID    landParcelID    = p.currentParcelUUID;
+
+            ILandObject land = p.Scene.LandChannel.GetLandObject(avaPos.X, avaPos.Y);
+
+            if (land != null)
+            {
+                // If land found, use parcel uuid from here because the value from SP will be blank if the avatar hasnt moved
+                landParcelName  = land.LandData.Name;
+                landParcelID    = land.LandData.GlobalID;
+            }
+            else
+            {
+                m_log.WarnFormat(
+                    "[PROFILES]: PickInfoUpdate found no parcel info at {0},{1} in {2}", 
+                    avaPos.X, avaPos.Y, p.Scene.Name);
+            }
+
+
+            pick.PickId = pickID;
+            pick.CreatorId = creatorID;
+            pick.TopPick = topPick;
+            pick.Name = name;
+            pick.Desc = desc;
+            pick.ParcelId = landParcelID;
+            pick.SnapshotId = snapshotID;
+            pick.ParcelName = landParcelName;
+            pick.SimName = remoteClient.Scene.RegionInfo.RegionName;
+            pick.Gatekeeper = MyGatekeeper;
+            pick.GlobalPos = posGlobal.ToString();
+            pick.SortOrder = sortOrder;
+            pick.Enabled = enabled;
+
+            object Pick = (object)pick;
+            if(!rpc.JsonRpcRequest(ref Pick, "picks_update", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAgentAlertMessage(
+                        "Error updating pick", false);
+                return;
+            }
+
+            m_log.DebugFormat("[PROFILES]: Finish PickInfoUpdate {0} {1}", pick.Name, pick.PickId.ToString());
+        }
+
+        /// <summary>
+        /// Delete a Pick
+        /// </summary>
+        /// <param name='remoteClient'>
+        /// Remote client.
+        /// </param>
+        /// <param name='queryPickID'>
+        /// Query pick I.
+        /// </param>
+        public void PickDelete(IClientAPI remoteClient, UUID queryPickID)
+        {
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+
+            OSDMap parameters= new OSDMap();
+            parameters.Add("pickId", OSD.FromUUID(queryPickID));
+            OSD Params = (OSD)parameters;
+            if(!rpc.JsonRpcRequest(ref Params, "picks_delete", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAgentAlertMessage(
+                        "Error picks delete", false);
+                return;
+            }
+        }
+        #endregion Picks
+
+        #region Notes
+        /// <summary>
+        /// Handles the avatar notes request.
+        /// </summary>
+        /// <param name='sender'>
+        /// Sender.
+        /// </param>
+        /// <param name='method'>
+        /// Method.
+        /// </param>
+        /// <param name='args'>
+        /// Arguments.
+        /// </param>
+        public void NotesRequest(Object sender, string method, List<String> args)
+        {
+            UserProfileNotes note = new UserProfileNotes();
+
+            if (!(sender is IClientAPI))
+                return;
+
+            IClientAPI remoteClient = (IClientAPI)sender;
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+            note.UserId = remoteClient.AgentId;
+            UUID.TryParse(args[0], out note.TargetId);
+
+            object Note = (object)note;
+            if(!rpc.JsonRpcRequest(ref Note, "avatarnotesrequest", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAvatarNotesReply(note.TargetId, note.Notes);
+                return;
+            }
+            note = (UserProfileNotes) Note;
+                
+            remoteClient.SendAvatarNotesReply(note.TargetId, note.Notes);
+        }
+
+        /// <summary>
+        /// Avatars the notes update.
+        /// </summary>
+        /// <param name='remoteClient'>
+        /// Remote client.
+        /// </param>
+        /// <param name='queryTargetID'>
+        /// Query target I.
+        /// </param>
+        /// <param name='queryNotes'>
+        /// Query notes.
+        /// </param>
+        public void NotesUpdate(IClientAPI remoteClient, UUID queryTargetID, string queryNotes)
+        {
+            UserProfileNotes note = new UserProfileNotes();
+
+            note.UserId = remoteClient.AgentId;
+            note.TargetId = queryTargetID;
+            note.Notes = queryNotes;
+
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+
+            object Note = note;
+            if(!rpc.JsonRpcRequest(ref Note, "avatar_notes_update", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAgentAlertMessage(
+                        "Error updating note", false);
+                return;
+            }
+        }
+        #endregion Notes
+
+        #region User Preferences
+        /// <summary>
+        /// Updates the user preferences.
+        /// </summary>
+        /// <param name='imViaEmail'>
+        /// Im via email.
+        /// </param>
+        /// <param name='visible'>
+        /// Visible.
+        /// </param>
+        /// <param name='remoteClient'>
+        /// Remote client.
+        /// </param>
+        public void UpdateUserPreferences(bool imViaEmail, bool visible, IClientAPI remoteClient)
+        {
+            UserPreferences pref = new UserPreferences();
+
+            pref.UserId = remoteClient.AgentId;
+            pref.IMViaEmail = imViaEmail;
+            pref.Visible = visible;
+
+            string serverURI = string.Empty;
+            bool foreign = GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+
+            object Pref = pref;
+            if(!rpc.JsonRpcRequest(ref Pref, "user_preferences_update", serverURI, UUID.Random().ToString()))
+            {
+                m_log.InfoFormat("[PROFILES]: UserPreferences update error");
+                remoteClient.SendAgentAlertMessage("Error updating preferences", false);
+                return;   
+            }
+        }
+        
+        /// <summary>
+        /// Users the preferences request.
+        /// </summary>
+        /// <param name='remoteClient'>
+        /// Remote client.
+        /// </param>
+        public void UserPreferencesRequest(IClientAPI remoteClient)
+        {
+            UserPreferences pref = new UserPreferences();
+
+            pref.UserId = remoteClient.AgentId;
+
+            string serverURI = string.Empty;
+            bool foreign = GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+
+
+            object Pref = (object)pref;
+            if(!rpc.JsonRpcRequest(ref Pref, "user_preferences_request", serverURI, UUID.Random().ToString()))
+            {
+//                m_log.InfoFormat("[PROFILES]: UserPreferences request error");
+//                remoteClient.SendAgentAlertMessage("Error requesting preferences", false);
+                return;
+            }
+            pref = (UserPreferences) Pref;
+
+            remoteClient.SendUserInfoReply(pref.IMViaEmail, pref.Visible, pref.EMail);
+       
+        }
+        #endregion User Preferences
+
+        #region Avatar Properties
+        /// <summary>
+        /// Update the avatars interests .
+        /// </summary>
+        /// <param name='remoteClient'>
+        /// Remote client.
+        /// </param>
+        /// <param name='wantmask'>
+        /// Wantmask.
+        /// </param>
+        /// <param name='wanttext'>
+        /// Wanttext.
+        /// </param>
+        /// <param name='skillsmask'>
+        /// Skillsmask.
+        /// </param>
+        /// <param name='skillstext'>
+        /// Skillstext.
+        /// </param>
+        /// <param name='languages'>
+        /// Languages.
+        /// </param>
+        public void AvatarInterestsUpdate(IClientAPI remoteClient, uint wantmask, string wanttext, uint skillsmask, string skillstext, string languages)
+        {
+            UserProfileProperties prop = new UserProfileProperties();
+
+            prop.UserId = remoteClient.AgentId;
+            prop.WantToMask = (int)wantmask;
+            prop.WantToText = wanttext;
+            prop.SkillsMask = (int)skillsmask;
+            prop.SkillsText = skillstext;
+            prop.Language = languages;
+
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+
+            object Param = prop;
+            if(!rpc.JsonRpcRequest(ref Param, "avatar_interests_update", serverURI, UUID.Random().ToString()))
+            {
+                remoteClient.SendAgentAlertMessage(
+                        "Error updating interests", false);
+                return;
+            }
+        }
+
+        public void RequestAvatarProperties(IClientAPI remoteClient, UUID avatarID)
+        {
+            if (String.IsNullOrEmpty(avatarID.ToString()) || String.IsNullOrEmpty(remoteClient.AgentId.ToString()))
+            {
+                // Looking for a reason that some viewers are sending null Id's
+                m_log.DebugFormat("[PROFILES]: This should not happen remoteClient.AgentId {0} - avatarID {1}", remoteClient.AgentId, avatarID);
+                return;
+            }
+
+            // Can't handle NPC yet...
+            ScenePresence p = FindPresence(avatarID);
+
+            if (null != p)
+            {
+                if (p.PresenceType == PresenceType.Npc)
+                    return;
+            }
+
+            string serverURI = string.Empty;
+            bool foreign = GetUserProfileServerURI(avatarID, out serverURI);
+
+            UserAccount account = null;
+            Dictionary<string,object> userInfo;
+
+            if (!foreign)
+            {
+                account = Scene.UserAccountService.GetUserAccount(Scene.RegionInfo.ScopeID, avatarID);
+            }
+            else
+            {
+                userInfo = new Dictionary<string, object>();
+            }
+
+            Byte[] charterMember = new Byte[1];
+            string born = String.Empty;
+            uint flags = 0x00;
+
+            if (null != account)
+            {
+                if (account.UserTitle == "")
+                {
+                    charterMember[0] = (Byte)((account.UserFlags & 0xf00) >> 8);
+                }
+                else
+                {
+                    charterMember = Utils.StringToBytes(account.UserTitle);
+                }
+
+                born = Util.ToDateTime(account.Created).ToString(
+                                  "M/d/yyyy", CultureInfo.InvariantCulture);
+                flags = (uint)(account.UserFlags & 0xff);
+            }
+            else
+            {
+                if (GetUserAccountData(avatarID, out userInfo) == true)
+                {
+                    if ((string)userInfo["user_title"] == "")
+                    {
+                        charterMember[0] = (Byte)(((Byte)userInfo["user_flags"] & 0xf00) >> 8);
+                    }
+                    else
+                    {
+                        charterMember = Utils.StringToBytes((string)userInfo["user_title"]);
+                    }
+
+                    int val_born = (int)userInfo["user_created"];
+                    born = Util.ToDateTime(val_born).ToString(
+                                  "M/d/yyyy", CultureInfo.InvariantCulture);
+
+                    // picky, picky
+                    int val_flags = (int)userInfo["user_flags"];
+                    flags = (uint)(val_flags & 0xff);
+                }
+            }
+
+            UserProfileProperties props = new UserProfileProperties();
+            string result = string.Empty;
+
+            props.UserId = avatarID;
+
+            if (!GetProfileData(ref props, foreign, out result))
+            {
+//                m_log.DebugFormat("Error getting profile for {0}: {1}", avatarID, result);
+                return;
+            }
+
+            remoteClient.SendAvatarProperties(props.UserId, props.AboutText, born, charterMember , props.FirstLifeText, flags,
+                                              props.FirstLifeImageId, props.ImageId, props.WebUrl, props.PartnerId);
+
+
+            remoteClient.SendAvatarInterestsReply(props.UserId, (uint)props.WantToMask, props.WantToText, (uint)props.SkillsMask,
+                                                  props.SkillsText, props.Language);
+        }
+
+        /// <summary>
+        /// Updates the avatar properties.
+        /// </summary>
+        /// <param name='remoteClient'>
+        /// Remote client.
+        /// </param>
+        /// <param name='newProfile'>
+        /// New profile.
+        /// </param>
+        public void AvatarPropertiesUpdate(IClientAPI remoteClient, UserProfileData newProfile)
+        {
+            if (remoteClient.AgentId == newProfile.ID)
+            {
+                UserProfileProperties prop = new UserProfileProperties();
+
+                prop.UserId = remoteClient.AgentId;
+                prop.WebUrl = newProfile.ProfileUrl;
+                prop.ImageId = newProfile.Image;
+                prop.AboutText = newProfile.AboutText;
+                prop.FirstLifeImageId = newProfile.FirstLifeImage;
+                prop.FirstLifeText = newProfile.FirstLifeAboutText;
+
+                string serverURI = string.Empty;
+                GetUserProfileServerURI(remoteClient.AgentId, out serverURI);
+
+                object Prop = prop;
+
+                if(!rpc.JsonRpcRequest(ref Prop, "avatar_properties_update", serverURI, UUID.Random().ToString()))
+                {
+                    remoteClient.SendAgentAlertMessage(
+                            "Error updating properties", false);
+                    return;
+                }
+
+                RequestAvatarProperties(remoteClient, newProfile.ID);
+            }
+        }
+
+        /// <summary>
+        /// Gets the profile data.
+        /// </summary>
+        /// <returns>
+        /// The profile data.
+        /// </returns>
+        bool GetProfileData(ref UserProfileProperties properties, bool foreign, out string message)
+        {
+            // Can't handle NPC yet...
+            ScenePresence p = FindPresence(properties.UserId);
+
+            if (null != p)
+            {
+                if (p.PresenceType == PresenceType.Npc)
+                {
+                    message = "Id points to NPC";
+                    return false;
+                }
+            }
+
+            string serverURI = string.Empty;
+            GetUserProfileServerURI(properties.UserId, out serverURI);
+
+            // This is checking a friend on the home grid
+            // Not HG friend
+            if (String.IsNullOrEmpty(serverURI))
+            {
+                message = "No Presence - foreign friend";
+                return false;
+            }
+
+            object Prop = (object)properties;
+            if (!rpc.JsonRpcRequest(ref Prop, "avatar_properties_request", serverURI, UUID.Random().ToString()))
+            {
+                // If it's a foreign user then try again using OpenProfile, in case that's what the grid is using
+                bool secondChanceSuccess = false;
+                if (foreign)
+                {
+                    try
+                    {
+                        OpenProfileClient client = new OpenProfileClient(serverURI);
+                        if (client.RequestAvatarPropertiesUsingOpenProfile(ref properties))
+                            secondChanceSuccess = true;
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Debug(
+                            string.Format(
+                                "[PROFILES]: Request using the OpenProfile API for user {0} to {1} failed", 
+                                properties.UserId, serverURI),
+                            e);
+
+                        // Allow the return 'message' to say "JsonRpcRequest" and not "OpenProfile", because
+                        // the most likely reason that OpenProfile failed is that the remote server
+                        // doesn't support OpenProfile, and that's not very interesting.
+                    }
+                }
+
+                if (!secondChanceSuccess)
+                {
+                    message = string.Format("JsonRpcRequest for user {0} to {1} failed", properties.UserId, serverURI);
+                    m_log.DebugFormat("[PROFILES]: {0}", message);
+
+                    return false;
+                }
+                // else, continue below
+            }
+            
+            properties = (UserProfileProperties)Prop;
+
+            message = "Success";
+            return true;
+        }
+        #endregion Avatar Properties
+
+        #region Utils
+        bool GetImageAssets(UUID avatarId)
+        {
+            string profileServerURI = string.Empty;
+            string assetServerURI = string.Empty;
+
+            bool foreign = GetUserProfileServerURI(avatarId, out profileServerURI);
+
+            if(!foreign)
+                return true;
+
+            assetServerURI = UserManagementModule.GetUserServerURL(avatarId, "AssetServerURI");
+
+            if(string.IsNullOrEmpty(profileServerURI) || string.IsNullOrEmpty(assetServerURI))
+                return false;
+
+            OSDMap parameters= new OSDMap();
+            parameters.Add("avatarId", OSD.FromUUID(avatarId));
+            OSD Params = (OSD)parameters;
+            if(!rpc.JsonRpcRequest(ref Params, "image_assets_request", profileServerURI, UUID.Random().ToString()))
+            {
+                return false;
+            }
+            
+            parameters = (OSDMap)Params;
+
+            if (parameters.ContainsKey("result"))
+            {
+                OSDArray list = (OSDArray)parameters["result"];
+
+                foreach (OSD asset in list)
+                {
+                    OSDString assetId = (OSDString)asset;
+
+                    Scene.AssetService.Get(string.Format("{0}/{1}", assetServerURI, assetId.AsString()));
+                }
+                return true;
+            }
+            else
+            {
+                m_log.ErrorFormat("[PROFILES]: Problematic response for image_assets_request from {0}", profileServerURI);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the user account data.
+        /// </summary>
+        /// <returns>
+        /// The user profile data.
+        /// </returns>
+        /// <param name='userID'>
+        /// If set to <c>true</c> user I.
+        /// </param>
+        /// <param name='userInfo'>
+        /// If set to <c>true</c> user info.
+        /// </param>
+        bool GetUserAccountData(UUID userID, out Dictionary<string, object> userInfo)
+        {
+            Dictionary<string,object> info = new Dictionary<string, object>();
+
+            if (UserManagementModule.IsLocalGridUser(userID))
+            {
+                // Is local
+                IUserAccountService uas = Scene.UserAccountService;
+                UserAccount account = uas.GetUserAccount(Scene.RegionInfo.ScopeID, userID);
+
+                info["user_flags"] = account.UserFlags;
+                info["user_created"] = account.Created;
+
+                if (!String.IsNullOrEmpty(account.UserTitle))
+                    info["user_title"] = account.UserTitle;
+                else
+                    info["user_title"] = "";
+
+                userInfo = info;
+
+                return false;
+            }
+            else
+            {
+                // Is Foreign
+                string home_url = UserManagementModule.GetUserServerURL(userID, "HomeURI");
+
+                if (String.IsNullOrEmpty(home_url))
+                {
+                    info["user_flags"] = 0;
+                    info["user_created"] = 0;
+                    info["user_title"] = "Unavailable";
+
+                    userInfo = info;
+                    return true;
+                }
+
+                UserAgentServiceConnector uConn = new UserAgentServiceConnector(home_url);
+
+                Dictionary<string, object> account;
+                try
+                {
+                    account = uConn.GetUserInfo(userID);
+                }
+                catch (Exception e)
+                {
+                    m_log.Debug("[PROFILES]: GetUserInfo call failed ", e);
+                    account = new Dictionary<string, object>();
+                }
+
+                if (account.Count > 0)
+                {
+                    if (account.ContainsKey("user_flags"))
+                        info["user_flags"] = account["user_flags"];
+                    else
+                        info["user_flags"] = "";
+
+                    if (account.ContainsKey("user_created"))
+                        info["user_created"] = account["user_created"];
+                    else
+                        info["user_created"] = "";
+
+                    info["user_title"] = "HG Visitor";
+                }
+                else
+                {
+                   info["user_flags"] = 0;
+                   info["user_created"] = 0;
+                   info["user_title"] = "HG Visitor";
+                }
+                userInfo = info;
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Gets the user gatekeeper server URI.
+        /// </summary>
+        /// <returns>
+        /// The user gatekeeper server URI.
+        /// </returns>
+        /// <param name='userID'>
+        /// If set to <c>true</c> user URI.
+        /// </param>
+        /// <param name='serverURI'>
+        /// If set to <c>true</c> server URI.
+        /// </param>
+        bool GetUserGatekeeperURI(UUID userID, out string serverURI)
+        {
+            bool local;
+            local = UserManagementModule.IsLocalGridUser(userID);
+            
+            if (!local)
+            {
+                serverURI = UserManagementModule.GetUserServerURL(userID, "GatekeeperURI");
+                // Is Foreign
+                return true;
+            }
+            else
+            {
+                serverURI = MyGatekeeper;
+                // Is local
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the user profile server UR.
+        /// </summary>
+        /// <returns>
+        /// The user profile server UR.
+        /// </returns>
+        /// <param name='userID'>
+        /// If set to <c>true</c> user I.
+        /// </param>
+        /// <param name='serverURI'>
+        /// If set to <c>true</c> server UR.
+        /// </param>
+        bool GetUserProfileServerURI(UUID userID, out string serverURI)
+        {
+            bool local;
+            local = UserManagementModule.IsLocalGridUser(userID);
+
+            if (!local)
+            {
+                serverURI = UserManagementModule.GetUserServerURL(userID, "ProfileServerURI");
+                // Is Foreign
+                return true;
+            }
+            else
+            {
+                serverURI = ProfileServerUri;
+                // Is local
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Finds the presence.
+        /// </summary>
+        /// <returns>
+        /// The presence.
+        /// </returns>
+        /// <param name='clientID'>
+        /// Client I.
+        /// </param>
+        ScenePresence FindPresence(UUID clientID)
+        {
+            ScenePresence p;
+
+            p = Scene.GetScenePresence(clientID);
+            if (p != null && !p.IsChildAgent)
+                return p;
+
+            return null;
+        }
+        #endregion Util
+    }
+}