this is step 2 of 2 of the OpenSim.Region.Environment refactor.

NOTHING has been deleted or moved off to forge at this point.  what
has happened is that OpenSim.Region.Environment.Modules has been split
in two:

- OpenSim.Region.CoreModules: all those modules that are either
  directly or indirectly referenced from  other  OpenSim packages, or
  that provide functionality that the OpenSim developer community
  considers core functionality:

      CoreModules/Agent/AssetTransaction
      CoreModules/Agent/Capabilities
      CoreModules/Agent/TextureDownload
      CoreModules/Agent/TextureSender
      CoreModules/Agent/TextureSender/Tests
      CoreModules/Agent/Xfer
      CoreModules/Avatar/AvatarFactory
      CoreModules/Avatar/Chat/ChatModule
      CoreModules/Avatar/Combat
      CoreModules/Avatar/Currency/SampleMoney
      CoreModules/Avatar/Dialog
      CoreModules/Avatar/Friends
      CoreModules/Avatar/Gestures
      CoreModules/Avatar/Groups
      CoreModules/Avatar/InstantMessage
      CoreModules/Avatar/Inventory
      CoreModules/Avatar/Inventory/Archiver
      CoreModules/Avatar/Inventory/Transfer
      CoreModules/Avatar/Lure
      CoreModules/Avatar/ObjectCaps
      CoreModules/Avatar/Profiles
      CoreModules/Communications/Local
      CoreModules/Communications/REST
      CoreModules/Framework/EventQueue
      CoreModules/Framework/InterfaceCommander
      CoreModules/Hypergrid
      CoreModules/InterGrid
      CoreModules/Scripting/DynamicTexture
      CoreModules/Scripting/EMailModules
      CoreModules/Scripting/HttpRequest
      CoreModules/Scripting/LoadImageURL
      CoreModules/Scripting/VectorRender
      CoreModules/Scripting/WorldComm
      CoreModules/Scripting/XMLRPC
      CoreModules/World/Archiver
      CoreModules/World/Archiver/Tests
      CoreModules/World/Estate
      CoreModules/World/Land
      CoreModules/World/Permissions
      CoreModules/World/Serialiser
      CoreModules/World/Sound
      CoreModules/World/Sun
      CoreModules/World/Terrain
      CoreModules/World/Terrain/DefaultEffects
      CoreModules/World/Terrain/DefaultEffects/bin
      CoreModules/World/Terrain/DefaultEffects/bin/Debug
      CoreModules/World/Terrain/Effects
      CoreModules/World/Terrain/FileLoaders
      CoreModules/World/Terrain/FloodBrushes
      CoreModules/World/Terrain/PaintBrushes
      CoreModules/World/Terrain/Tests
      CoreModules/World/Vegetation
      CoreModules/World/Wind
      CoreModules/World/WorldMap

- OpenSim.Region.OptionalModules: all those modules that are not core
  modules:

      OptionalModules/Avatar/Chat/IRC-stuff
      OptionalModules/Avatar/Concierge
      OptionalModules/Avatar/Voice/AsterixVoice
      OptionalModules/Avatar/Voice/SIPVoice
      OptionalModules/ContentManagementSystem
      OptionalModules/Grid/Interregion
      OptionalModules/Python
      OptionalModules/SvnSerialiser
      OptionalModules/World/NPC
      OptionalModules/World/TreePopulator

17 files changed, 6606 insertions, 0 deletions

diff --git a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
new file mode 100644
index 0000000..d084dbd
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
@@ -0,0 +1,232 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications.Cache;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
+{
+    public class AvatarFactoryModule : IAvatarFactory, IRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private Scene m_scene = null;
+        private static readonly AvatarAppearance def = new AvatarAppearance();
+
+        public bool TryGetAvatarAppearance(UUID avatarId, out AvatarAppearance appearance)
+        {
+            CachedUserInfo profile = m_scene.CommsManager.UserProfileCacheService.GetUserDetails(avatarId);
+            //if ((profile != null) && (profile.RootFolder != null))
+            if (profile != null)
+            {
+                appearance = m_scene.CommsManager.AvatarService.GetUserAppearance(avatarId);
+                if (appearance != null)
+                {
+                    //SetAppearanceAssets(profile, ref appearance);
+                    //m_log.DebugFormat("[APPEARANCE]: Found : {0}", appearance.ToString());
+                    return true;
+                }
+            }
+
+            appearance = CreateDefault(avatarId);
+            m_log.ErrorFormat("[APPEARANCE]: Appearance not found for {0}, creating default", avatarId);
+            return false;
+        }
+
+        private AvatarAppearance CreateDefault(UUID avatarId)
+        {
+            AvatarAppearance appearance = null;
+            AvatarWearable[] wearables;
+            byte[] visualParams;
+            GetDefaultAvatarAppearance(out wearables, out visualParams);
+            appearance = new AvatarAppearance(avatarId, wearables, visualParams);
+
+            return appearance;
+        }
+
+        public void Initialise(Scene scene, IConfigSource source)
+        {
+            scene.RegisterModuleInterface<IAvatarFactory>(this);
+            scene.EventManager.OnNewClient += NewClient;
+
+            if (m_scene == null)
+            {
+                m_scene = scene;
+            }
+
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "Default Avatar Factory"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+
+        public void NewClient(IClientAPI client)
+        {
+            client.OnAvatarNowWearing += AvatarIsWearing;
+        }
+
+        public void RemoveClient(IClientAPI client)
+        {
+            // client.OnAvatarNowWearing -= AvatarIsWearing;
+        }
+
+
+        public void SetAppearanceAssets(CachedUserInfo profile, ref AvatarAppearance appearance)
+        {
+            if (profile.RootFolder != null)
+            {
+                for (int i = 0; i < 13; i++)
+                {
+                    if (appearance.Wearables[i].ItemID == UUID.Zero)
+                    {
+                        appearance.Wearables[i].AssetID = UUID.Zero;
+                    }
+                    else
+                    {
+                        InventoryItemBase baseItem = profile.RootFolder.FindItem(appearance.Wearables[i].ItemID);
+
+                        if (baseItem != null)
+                        {
+                            appearance.Wearables[i].AssetID = baseItem.AssetID;
+                        }
+                        else
+                        {
+                            m_log.ErrorFormat("[APPEARANCE]: Can't find inventory item {0}, setting to default", appearance.Wearables[i].ItemID);
+                            appearance.Wearables[i].AssetID = def.Wearables[i].AssetID;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                m_log.Error("[APPEARANCE]: you have no inventory, appearance stuff isn't going to work");
+            }
+        }
+
+        /// <summary>
+        /// Update what the avatar is wearing using an item from their inventory.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        public void AvatarIsWearing(Object sender, AvatarWearingArgs e)
+        {
+            IClientAPI clientView = (IClientAPI)sender;
+            ScenePresence avatar = m_scene.GetScenePresence(clientView.AgentId);
+            
+            if (avatar == null) 
+            {
+                m_log.Error("[APPEARANCE]: Avatar is child agent, ignoring AvatarIsWearing event");
+                return;
+            }
+
+            CachedUserInfo profile = m_scene.CommsManager.UserProfileCacheService.GetUserDetails(clientView.AgentId);
+
+            AvatarAppearance avatAppearance = null;
+            if (!TryGetAvatarAppearance(clientView.AgentId, out avatAppearance)) 
+            {
+                m_log.Warn("[APPEARANCE]: We didn't seem to find the appearance, falling back to ScenePresence");
+                avatAppearance = avatar.Appearance;
+            }
+            
+            //m_log.DebugFormat("[APPEARANCE]: Received wearables for {0}", clientView.Name);
+            
+            if (profile != null)
+            {
+                if (profile.RootFolder != null)
+                {
+                    foreach (AvatarWearingArgs.Wearable wear in e.NowWearing)
+                    {
+                        if (wear.Type < 13)
+                        {
+                            avatAppearance.Wearables[wear.Type].ItemID = wear.ItemID;
+                        }
+                    }
+                    
+                    SetAppearanceAssets(profile, ref avatAppearance);
+
+                    m_scene.CommsManager.AvatarService.UpdateUserAppearance(clientView.AgentId, avatAppearance);
+                    avatar.Appearance = avatAppearance;
+                }
+                else
+                {
+                    m_log.WarnFormat(
+                        "[APPEARANCE]: Inventory has not yet been received for {0}, cannot set wearables", 
+                        clientView.Name);
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("[APPEARANCE]: Cannot set wearables for {0}, no user profile found", clientView.Name);
+            }
+        }
+
+        public static void GetDefaultAvatarAppearance(out AvatarWearable[] wearables, out byte[] visualParams)
+        {
+            visualParams = GetDefaultVisualParams();
+            wearables = AvatarWearable.DefaultWearables;
+        }
+
+        public void UpdateDatabase(UUID user, AvatarAppearance appearance)
+        {
+            m_scene.CommsManager.AvatarService.UpdateUserAppearance(user, appearance);
+        }
+
+        private static byte[] GetDefaultVisualParams()
+        {
+            byte[] visualParams;
+            visualParams = new byte[218];
+            for (int i = 0; i < 218; i++)
+            {
+                visualParams[i] = 100;
+            }
+            return visualParams;
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs b/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
new file mode 100644
index 0000000..f036faf
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
@@ -0,0 +1,287 @@
+/*
+ * 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 OpenSim 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.Net.Sockets;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.Chat
+{
+    public class ChatModule : IRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private const int DEBUG_CHANNEL = 2147483647;
+
+        private bool m_enabled = true;
+        private int m_saydistance = 30;
+        private int m_shoutdistance = 100;
+        private int m_whisperdistance = 10;
+        private List<Scene> m_scenes = new List<Scene>();
+
+        internal object m_syncInit = new object();
+
+        #region IRegionModule Members
+        public virtual void Initialise(Scene scene, IConfigSource config)
+        {
+            // wrap this in a try block so that defaults will work if
+            // the config file doesn't specify otherwise.
+            try
+            {
+                m_enabled = config.Configs["Chat"].GetBoolean("enabled", m_enabled);
+                if (!m_enabled) return;
+
+                m_whisperdistance = config.Configs["Chat"].GetInt("whisper_distance", m_whisperdistance);
+                m_saydistance = config.Configs["Chat"].GetInt("say_distance", m_saydistance);
+                m_shoutdistance = config.Configs["Chat"].GetInt("shout_distance", m_shoutdistance);
+            }
+            catch (Exception)
+            {
+            }
+
+            lock (m_syncInit)
+            {
+                if (!m_scenes.Contains(scene))
+                {
+                    m_scenes.Add(scene);
+                    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);
+        }
+        public virtual void PostInitialise()
+        {
+        }
+
+        public virtual void Close()
+        {
+        }
+
+        public virtual string Name
+        {
+            get { return "ChatModule"; }
+        }
+
+        public virtual bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        #endregion
+
+
+        public virtual void OnNewClient(IClientAPI client)
+        {
+            client.OnChatFromClient += OnChatFromClient;
+        }
+
+        protected OSChatMessage FixPositionOfChatMessage(OSChatMessage c)
+        {
+            ScenePresence avatar;
+            Scene scene = (Scene)c.Scene;
+            if ((avatar = scene.GetScenePresence(c.Sender.AgentId)) != null)
+                c.Position = avatar.AbsolutePosition;
+
+            return c;
+        }
+
+        public virtual void OnChatFromClient(Object sender, OSChatMessage c)
+        {
+            c = FixPositionOfChatMessage(c);
+
+            // redistribute to interested subscribers
+            Scene scene = (Scene)c.Scene;
+            scene.EventManager.TriggerOnChatFromClient(sender, c);
+
+            // early return if not on public or debug channel
+            if (c.Channel != 0 && c.Channel != DEBUG_CHANNEL) return;
+
+            // sanity check:
+            if (c.Sender == null)
+            {
+                m_log.ErrorFormat("[CHAT] OnChatFromClient from {0} has empty Sender field!", sender);
+                return;
+            }
+
+            DeliverChatToAvatars(ChatSourceType.Agent, c);
+        }
+
+        public virtual void OnChatFromWorld(Object sender, OSChatMessage c)
+        {
+            // early return if not on public or debug channel
+            if (c.Channel != 0 && c.Channel != DEBUG_CHANNEL) return;
+
+            DeliverChatToAvatars(ChatSourceType.Object, c);
+        }
+
+        protected virtual void DeliverChatToAvatars(ChatSourceType sourceType, OSChatMessage c)
+        {
+            string fromName = c.From;
+            UUID fromID = UUID.Zero;
+            string message = c.Message;
+            IScene scene = c.Scene;
+            Vector3 fromPos = c.Position;
+            Vector3 regionPos = new Vector3(scene.RegionInfo.RegionLocX * Constants.RegionSize,
+                                            scene.RegionInfo.RegionLocY * Constants.RegionSize, 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);
+                fromPos = avatar.AbsolutePosition;
+                fromName = avatar.Name;
+                fromID = c.Sender.AgentId;
+
+                break;
+
+            case ChatSourceType.Object:
+                fromID = c.SenderUUID;
+
+                break;
+            }
+
+            // TODO: iterate over message
+            if (message.Length >= 1000) // libomv limit
+                message = message.Substring(0, 1000);
+
+            // m_log.DebugFormat("[CHAT]: DCTA: fromID {0} fromName {1}, cType {2}, sType {3}", fromID, fromName, c.Type, sourceType);
+
+            foreach (Scene s in m_scenes)
+            {
+                s.ForEachScenePresence(delegate(ScenePresence presence) 
+                                       {
+                                           TrySendChatMessage(presence, fromPos, regionPos, fromID, fromName, 
+                                                              c.Type, message, sourceType);
+                                       });
+            }
+        }
+
+
+        static private Vector3 CenterOfRegion = new Vector3(128, 128, 30);
+        public virtual void OnChatBroadcast(Object sender, OSChatMessage c)
+        {
+            // unless the chat to be broadcast is of type Region, we
+            // drop it if its channel is neither 0 nor DEBUG_CHANNEL
+            if (c.Channel != 0 && c.Channel != DEBUG_CHANNEL && c.Type != ChatTypeEnum.Region) return;
+
+            ChatTypeEnum cType = c.Type;
+            if (c.Channel == DEBUG_CHANNEL)
+                cType = ChatTypeEnum.DebugChannel;
+
+            if (cType == ChatTypeEnum.Region)
+                cType = ChatTypeEnum.Say;
+
+            if (c.Message.Length > 1100)
+                c.Message = c.Message.Substring(0, 1000);
+
+            // broadcast chat works by redistributing every incoming chat
+            // message to each avatar in the scene.
+            string fromName = c.From;
+            
+            UUID fromID = 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;
+                sourceType = ChatSourceType.Agent;
+            }
+            
+            // m_log.DebugFormat("[CHAT] Broadcast: fromID {0} fromName {1}, cType {2}, sType {3}", fromID, fromName, cType, sourceType);
+
+            ((Scene)c.Scene).ForEachScenePresence(
+                delegate(ScenePresence presence)
+                {
+                    // ignore chat from child agents
+                    if (presence.IsChildAgent) return;
+                    
+                    IClientAPI client = presence.ControllingClient;
+                    
+                    // don't forward SayOwner chat from objects to
+                    // non-owner agents
+                    if ((c.Type == ChatTypeEnum.Owner) &&
+                        (null != c.SenderObject) &&
+                        (((SceneObjectPart)c.SenderObject).OwnerID != client.AgentId))
+                        return;
+                    
+                    client.SendChatMessage(c.Message, (byte)cType, CenterOfRegion, fromName, fromID, 
+                                           (byte)sourceType, (byte)ChatAudibleLevel.Fully);
+                });
+        }
+
+
+        protected virtual void TrySendChatMessage(ScenePresence presence, Vector3 fromPos, Vector3 regionPos,
+                                                  UUID fromAgentID, string fromName, ChatTypeEnum type,
+                                                  string message, ChatSourceType src)
+        {
+            // don't send stuff to child agents
+            if (presence.IsChildAgent) return;
+
+            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 = Math.Abs((int) Util.GetDistanceTo(toRegionPos, fromRegionPos));
+
+            if (type == ChatTypeEnum.Whisper && dis > m_whisperdistance ||
+                type == ChatTypeEnum.Say && dis > m_saydistance ||
+                type == ChatTypeEnum.Shout && dis > m_shoutdistance)
+            {
+                return;
+            }
+
+            // TODO: should change so the message is sent through the avatar rather than direct to the ClientView
+            presence.ControllingClient.SendChatMessage(message, (byte) type, fromPos, fromName,
+                                                       fromAgentID,(byte)src,(byte)ChatAudibleLevel.Fully);
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs b/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
new file mode 100644
index 0000000..1ed608a
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
@@ -0,0 +1,154 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using System.Reflection;
+using System.Xml;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Communications.Cache;
+
+namespace OpenSim.Region.CoreModules.Avatar.Combat.CombatModule
+{
+    public class CombatModule : IRegionModule
+    {
+        //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Region UUIDS indexed by AgentID
+        /// </summary>
+        //private Dictionary<UUID, UUID> m_rootAgents = new Dictionary<UUID, UUID>();
+
+        /// <summary>
+        /// Scenes by Region Handle
+        /// </summary>
+        private Dictionary<ulong, Scene> m_scenel = new Dictionary<ulong, Scene>();
+
+        /// <summary>
+        /// Startup
+        /// </summary>
+        /// <param name="scene"></param>
+        /// <param name="config"></param>
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            lock (m_scenel)
+            {
+                if (m_scenel.ContainsKey(scene.RegionInfo.RegionHandle))
+                {
+                    m_scenel[scene.RegionInfo.RegionHandle] = scene;
+                }
+                else
+                {
+                    m_scenel.Add(scene.RegionInfo.RegionHandle, scene);
+                }
+            }
+
+            scene.EventManager.OnAvatarKilled += KillAvatar;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "CombatModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        private void KillAvatar(uint killerObjectLocalID, ScenePresence DeadAvatar)
+        {
+            if (killerObjectLocalID == 0)
+                DeadAvatar.ControllingClient.SendAgentAlertMessage("You committed suicide!", true);
+            else
+            {
+                bool foundResult = false;
+                string resultstring = "";
+                List<ScenePresence> allav = DeadAvatar.Scene.GetScenePresences();
+                try
+                {
+                    foreach (ScenePresence av in allav)
+                    {
+                        if (av.LocalId == killerObjectLocalID)
+                        {
+                            av.ControllingClient.SendAlertMessage("You fragged " + DeadAvatar.Firstname + " " + DeadAvatar.Lastname);
+                            resultstring = av.Firstname + " " + av.Lastname;
+                            foundResult = true;
+                        }
+                    }
+                } catch (System.InvalidOperationException)
+                {
+
+                }
+
+                if (!foundResult)
+                {
+                    SceneObjectPart part = DeadAvatar.Scene.GetSceneObjectPart(killerObjectLocalID);
+                    if (part != null)
+                    {
+                        ScenePresence av = DeadAvatar.Scene.GetScenePresence(part.OwnerID);
+                        if (av != null)
+                        {
+                            av.ControllingClient.SendAlertMessage("You fragged " + DeadAvatar.Firstname + " " + DeadAvatar.Lastname);
+                            resultstring = av.Firstname + " " + av.Lastname;
+                            DeadAvatar.ControllingClient.SendAgentAlertMessage("You got killed by " + resultstring + "!", true);
+                        }
+                        else
+                        {
+                            string killer = DeadAvatar.Scene.CommsManager.UUIDNameRequestString(part.OwnerID);
+                            DeadAvatar.ControllingClient.SendAgentAlertMessage("You impaled yourself on " + part.Name + " owned by " + killer +"!", true);
+                        }
+                        //DeadAvatar.Scene. part.ObjectOwner
+                    }
+                    else
+                    {
+                        DeadAvatar.ControllingClient.SendAgentAlertMessage("You died!", true);
+                    }
+                }
+            }
+            DeadAvatar.Health = 100;
+            DeadAvatar.Scene.TeleportClientHome(DeadAvatar.UUID, DeadAvatar.ControllingClient);
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Currency/SampleMoney/SampleMoneyModule.cs b/OpenSim/Region/CoreModules/Avatar/Currency/SampleMoney/SampleMoneyModule.cs
new file mode 100644
index 0000000..0a1de44
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Currency/SampleMoney/SampleMoneyModule.cs
@@ -0,0 +1,1605 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using System.Reflection;
+using System.Xml;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications.Cache;
+using OpenSim.Framework.Servers;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.Currency.SampleMoney
+{
+    /// <summary>
+    /// Demo Economy/Money Module.  This is not a production quality money/economy module!
+    /// This is a demo for you to use when making one that works for you.
+    ///  // To use the following you need to add:
+    /// -helperuri <ADDRESS TO HERE OR grid MONEY SERVER>
+    /// to the command line parameters you use to start up your client
+    /// This commonly looks like -helperuri http://127.0.0.1:9000/
+    ///
+    /// Centralized grid structure example using OpenSimWi Redux revision 9+
+    /// svn co https://opensimwiredux.svn.sourceforge.net/svnroot/opensimwiredux
+    /// </summary>
+    public class SampleMoneyModule : IMoneyModule, IRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Where Stipends come from and Fees go to.
+        /// </summary>
+        // private UUID EconomyBaseAccount = UUID.Zero;
+
+        private float EnergyEfficiency = 0f;
+        private bool gridmode = false;
+        // private ObjectPaid handerOnObjectPaid;
+        private bool m_enabled = true;
+
+        private IConfigSource m_gConfig;
+
+        private bool m_keepMoneyAcrossLogins = true;
+        private Dictionary<UUID, int> m_KnownClientFunds = new Dictionary<UUID, int>();
+        // private string m_LandAddress = String.Empty;
+
+        private int m_minFundsBeforeRefresh = 100;
+        private string m_MoneyAddress = String.Empty;
+
+        /// <summary>
+        /// Region UUIDS indexed by AgentID
+        /// </summary>
+        private Dictionary<UUID, UUID> m_rootAgents = new Dictionary<UUID, UUID>();
+
+        /// <summary>
+        /// Scenes by Region Handle
+        /// </summary>
+        private Dictionary<ulong, Scene> m_scenel = new Dictionary<ulong, Scene>();
+
+        private int m_stipend = 1000;
+
+        private int ObjectCapacity = 45000;
+        private int ObjectCount = 0;
+        private int PriceEnergyUnit = 0;
+        private int PriceGroupCreate = 0;
+        private int PriceObjectClaim = 0;
+        private float PriceObjectRent = 0f;
+        private float PriceObjectScaleFactor = 0f;
+        private int PriceParcelClaim = 0;
+        private float PriceParcelClaimFactor = 0f;
+        private int PriceParcelRent = 0;
+        private int PricePublicObjectDecay = 0;
+        private int PricePublicObjectDelete = 0;
+        private int PriceRentLight = 0;
+        private int PriceUpload = 0;
+        private int TeleportMinPrice = 0;
+
+        private float TeleportPriceExponent = 0f;
+        // private int UserLevelPaysFees = 2;
+        // private Scene XMLRPCHandler;
+
+        #region IMoneyModule Members
+
+        public event ObjectPaid OnObjectPaid;
+
+        /// <summary>
+        /// Startup
+        /// </summary>
+        /// <param name="scene"></param>
+        /// <param name="config"></param>
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            m_gConfig = config;
+
+            IConfig startupConfig = m_gConfig.Configs["Startup"];
+            IConfig economyConfig = m_gConfig.Configs["Economy"];
+
+
+            ReadConfigAndPopulate(scene, startupConfig, "Startup");
+            ReadConfigAndPopulate(scene, economyConfig, "Economy");
+
+            if (m_enabled)
+            {
+                scene.RegisterModuleInterface<IMoneyModule>(this);
+                BaseHttpServer httpServer = scene.CommsManager.HttpServer;
+
+                lock (m_scenel)
+                {
+                    if (m_scenel.Count == 0)
+                    {
+                        // XMLRPCHandler = scene;
+
+                        // To use the following you need to add:
+                        // -helperuri <ADDRESS TO HERE OR grid MONEY SERVER>
+                        // to the command line parameters you use to start up your client
+                        // This commonly looks like -helperuri http://127.0.0.1:9000/
+
+                        if (m_MoneyAddress.Length > 0)
+                        {
+                            // Centralized grid structure using OpenSimWi Redux revision 9+
+                            // https://opensimwiredux.svn.sourceforge.net/svnroot/opensimwiredux
+                            httpServer.AddXmlRPCHandler("balanceUpdateRequest", GridMoneyUpdate);
+                            httpServer.AddXmlRPCHandler("userAlert", UserAlert);
+                        }
+                        else
+                        {
+                            // Local Server..  enables functionality only.
+                            httpServer.AddXmlRPCHandler("getCurrencyQuote", quote_func);
+                            httpServer.AddXmlRPCHandler("buyCurrency", buy_func);
+                            httpServer.AddXmlRPCHandler("preflightBuyLandPrep", preflightBuyLandPrep_func);
+                            httpServer.AddXmlRPCHandler("buyLandPrep", landBuy_func);
+                        }
+                    }
+
+                    if (m_scenel.ContainsKey(scene.RegionInfo.RegionHandle))
+                    {
+                        m_scenel[scene.RegionInfo.RegionHandle] = scene;
+                    }
+                    else
+                    {
+                        m_scenel.Add(scene.RegionInfo.RegionHandle, scene);
+                    }
+                }
+
+                scene.EventManager.OnNewClient += OnNewClient;
+                scene.EventManager.OnMoneyTransfer += MoneyTransferAction;
+                scene.EventManager.OnClientClosed += ClientClosed;
+                scene.EventManager.OnAvatarEnteringNewParcel += AvatarEnteringParcel;
+                scene.EventManager.OnMakeChildAgent += MakeChildAgent;
+                scene.EventManager.OnClientClosed += ClientLoggedOut;
+                scene.EventManager.OnValidateLandBuy += ValidateLandBuy;
+                scene.EventManager.OnLandBuy += processLandBuy;
+            }
+        }
+
+        // Please do not refactor these to be just one method
+        // Existing implementations need the distinction
+        //
+        public void ApplyUploadCharge(UUID agentID)
+        {
+        }
+
+        public void ApplyGroupCreationCharge(UUID agentID)
+        {
+        }
+
+        public void ApplyCharge(UUID agentID, int amount, string text)
+        {
+        }
+
+        public bool ObjectGiveMoney(UUID objectID, UUID fromID, UUID toID, int amount)
+        {
+            string description = String.Format("Object {0} pays {1}", resolveObjectName(objectID), resolveAgentName(toID));
+
+            bool give_result = doMoneyTransfer(fromID, toID, amount, 2, description);
+
+            if (m_MoneyAddress.Length == 0)
+                BalanceUpdate(fromID, toID, give_result, description);
+
+            return give_result;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "BetaGridLikeMoneyModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Parse Configuration
+        /// </summary>
+        /// <param name="scene"></param>
+        /// <param name="startupConfig"></param>
+        /// <param name="config"></param>
+        private void ReadConfigAndPopulate(Scene scene, IConfig startupConfig, string config)
+        {
+            if (config == "Startup" && startupConfig != null)
+            {
+                gridmode = startupConfig.GetBoolean("gridmode", false);
+                m_enabled = (startupConfig.GetString("economymodule", "BetaGridLikeMoneyModule") == "BetaGridLikeMoneyModule");
+            }
+
+            if (config == "Economy" && startupConfig != null)
+            {
+                ObjectCapacity = startupConfig.GetInt("ObjectCapacity", 45000);
+                PriceEnergyUnit = startupConfig.GetInt("PriceEnergyUnit", 100);
+                PriceObjectClaim = startupConfig.GetInt("PriceObjectClaim", 10);
+                PricePublicObjectDecay = startupConfig.GetInt("PricePublicObjectDecay", 4);
+                PricePublicObjectDelete = startupConfig.GetInt("PricePublicObjectDelete", 4);
+                PriceParcelClaim = startupConfig.GetInt("PriceParcelClaim", 1);
+                PriceParcelClaimFactor = startupConfig.GetFloat("PriceParcelClaimFactor", 1f);
+                PriceUpload = startupConfig.GetInt("PriceUpload", 0);
+                PriceRentLight = startupConfig.GetInt("PriceRentLight", 5);
+                TeleportMinPrice = startupConfig.GetInt("TeleportMinPrice", 2);
+                TeleportPriceExponent = startupConfig.GetFloat("TeleportPriceExponent", 2f);
+                EnergyEfficiency = startupConfig.GetFloat("EnergyEfficiency", 1);
+                PriceObjectRent = startupConfig.GetFloat("PriceObjectRent", 1);
+                PriceObjectScaleFactor = startupConfig.GetFloat("PriceObjectScaleFactor", 10);
+                PriceParcelRent = startupConfig.GetInt("PriceParcelRent", 1);
+                PriceGroupCreate = startupConfig.GetInt("PriceGroupCreate", -1);
+                // string EBA = startupConfig.GetString("EconomyBaseAccount", UUID.Zero.ToString());
+                // Helpers.TryParse(EBA, out EconomyBaseAccount);
+
+                // UserLevelPaysFees = startupConfig.GetInt("UserLevelPaysFees", -1);
+                m_stipend = startupConfig.GetInt("UserStipend", 500);
+                m_minFundsBeforeRefresh = startupConfig.GetInt("IssueStipendWhenClientIsBelowAmount", 10);
+                m_keepMoneyAcrossLogins = startupConfig.GetBoolean("KeepMoneyAcrossLogins", true);
+                m_MoneyAddress = startupConfig.GetString("CurrencyServer", String.Empty);
+                // m_LandAddress = startupConfig.GetString("LandServer", String.Empty);
+            }
+
+            // Send ObjectCapacity to Scene..  Which sends it to the SimStatsReporter.
+            scene.SetObjectCapacity(ObjectCapacity);
+        }
+
+        public EconomyData GetEconomyData()
+        {
+            EconomyData edata = new EconomyData();
+            edata.ObjectCapacity = ObjectCapacity;
+            edata.ObjectCount = ObjectCount;
+            edata.PriceEnergyUnit = PriceEnergyUnit;
+            edata.PriceGroupCreate = PriceGroupCreate;
+            edata.PriceObjectClaim = PriceObjectClaim;
+            edata.PriceObjectRent = PriceObjectRent;
+            edata.PriceObjectScaleFactor = PriceObjectScaleFactor;
+            edata.PriceParcelClaim = PriceParcelClaim;
+            edata.PriceParcelClaimFactor = PriceParcelClaimFactor;
+            edata.PriceParcelRent = PriceParcelRent;
+            edata.PricePublicObjectDecay = PricePublicObjectDecay;
+            edata.PricePublicObjectDelete = PricePublicObjectDelete;
+            edata.PriceRentLight = PriceRentLight;
+            edata.PriceUpload = PriceUpload;
+            edata.TeleportMinPrice = TeleportMinPrice;
+            return edata;
+        }
+
+        private void GetClientFunds(IClientAPI client)
+        {
+            // Here we check if we're in grid mode
+            // I imagine that the 'check balance'
+            // function for the client should be here or shortly after
+
+            if (gridmode)
+            {
+                if (m_MoneyAddress.Length == 0)
+                {
+                    CheckExistAndRefreshFunds(client.AgentId);
+                }
+                else
+                {
+                    bool childYN = true;
+                    ScenePresence agent = null;
+                    //client.SecureSessionId;
+                    Scene s = LocateSceneClientIn(client.AgentId);
+                    if (s != null)
+                    {
+                        agent = s.GetScenePresence(client.AgentId);
+                        if (agent != null)
+                            childYN = agent.IsChildAgent;
+                    }
+                    if (s != null && agent != null && childYN == false)
+                    {
+                        //s.RegionInfo.RegionHandle;
+                        UUID agentID = UUID.Zero;
+                        int funds = 0;
+
+                        Hashtable hbinfo =
+                            GetBalanceForUserFromMoneyServer(client.AgentId, client.SecureSessionId, s.RegionInfo.originRegionID,
+                                                             s.RegionInfo.regionSecret);
+                        if ((bool) hbinfo["success"] == true)
+                        {
+                            UUID.TryParse((string)hbinfo["agentId"], out agentID);
+                            try
+                            {
+                                funds = (Int32) hbinfo["funds"];
+                            }
+                            catch (ArgumentException)
+                            {
+                            }
+                            catch (FormatException)
+                            {
+                            }
+                            catch (OverflowException)
+                            {
+                                m_log.ErrorFormat("[MONEY]: While getting the Currency for user {0}, the return funds overflowed.", agentID);
+                                client.SendAlertMessage("Unable to get your money balance, money operations will be unavailable");
+                            }
+                            catch (InvalidCastException)
+                            {
+                                funds = 0;
+                            }
+
+                            m_KnownClientFunds[agentID] = funds;
+                        }
+                        else
+                        {
+                            m_log.WarnFormat("[MONEY]: Getting Money for user {0} failed with the following message:{1}", agentID,
+                                             (string) hbinfo["errorMessage"]);
+                            client.SendAlertMessage((string) hbinfo["errorMessage"]);
+                        }
+                        SendMoneyBalance(client, agentID, client.SessionId, UUID.Zero);
+                    }
+                }
+            }
+            else
+            {
+                CheckExistAndRefreshFunds(client.AgentId);
+            }
+
+        }
+
+        /// <summary>
+        /// New Client Event Handler
+        /// </summary>
+        /// <param name="client"></param>
+        private void OnNewClient(IClientAPI client)
+        {
+            GetClientFunds(client);
+
+            // Subscribe to Money messages
+            client.OnEconomyDataRequest += EconomyDataRequestHandler;
+            client.OnMoneyBalanceRequest += SendMoneyBalance;
+            client.OnRequestPayPrice += requestPayPrice;
+            client.OnObjectBuy += ObjectBuy;
+            client.OnLogout += ClientClosed;
+        }
+
+        /// <summary>
+        /// Transfer money
+        /// </summary>
+        /// <param name="Sender"></param>
+        /// <param name="Receiver"></param>
+        /// <param name="amount"></param>
+        /// <returns></returns>
+        private bool doMoneyTransfer(UUID Sender, UUID Receiver, int amount, int transactiontype, string description)
+        {
+            bool result = false;
+            if (amount >= 0)
+            {
+                lock (m_KnownClientFunds)
+                {
+                    // If we don't know about the sender, then the sender can't
+                    // actually be here and therefore this is likely fraud or outdated.
+                    if (m_MoneyAddress.Length == 0)
+                    {
+                        if (m_KnownClientFunds.ContainsKey(Sender))
+                        {
+                            // Does the sender have enough funds to give?
+                            if (m_KnownClientFunds[Sender] >= amount)
+                            {
+                                // Subtract the funds from the senders account
+                                m_KnownClientFunds[Sender] -= amount;
+
+                                // do we know about the receiver?
+                                if (!m_KnownClientFunds.ContainsKey(Receiver))
+                                {
+                                    // Make a record for them so they get the updated balance when they login
+                                    CheckExistAndRefreshFunds(Receiver);
+                                }
+                                if (m_enabled)
+                                {
+                                    //Add the amount to the Receiver's funds
+                                    m_KnownClientFunds[Receiver] += amount;
+                                    result = true;
+                                }
+                            }
+                            else
+                            {
+                                // These below are redundant to make this clearer to read
+                                result = false;
+                            }
+                        }
+                        else
+                        {
+                            result = false;
+                        }
+                    }
+                    else
+                    {
+                        result = TransferMoneyonMoneyServer(Sender, Receiver, amount, transactiontype, description);
+                    }
+                }
+            }
+            return result;
+        }
+
+
+        /// <summary>
+        /// Sends the the stored money balance to the client
+        /// </summary>
+        /// <param name="client"></param>
+        /// <param name="agentID"></param>
+        /// <param name="SessionID"></param>
+        /// <param name="TransactionID"></param>
+        public void SendMoneyBalance(IClientAPI client, UUID agentID, UUID SessionID, UUID TransactionID)
+        {
+            if (client.AgentId == agentID && client.SessionId == SessionID)
+            {
+                int returnfunds = 0;
+
+                try
+                {
+                    returnfunds = GetFundsForAgentID(agentID);
+                }
+                catch (Exception e)
+                {
+                    client.SendAlertMessage(e.Message + " ");
+                }
+
+                client.SendMoneyBalance(TransactionID, true, new byte[0], returnfunds);
+            }
+            else
+            {
+                client.SendAlertMessage("Unable to send your money balance to you!");
+            }
+        }
+
+        /// <summary>
+        /// Gets the current balance for the user from the Grid Money Server
+        /// </summary>
+        /// <param name="agentId"></param>
+        /// <param name="secureSessionID"></param>
+        /// <param name="regionId"></param>
+        /// <param name="regionSecret"></param>
+        /// <returns></returns>
+        public Hashtable GetBalanceForUserFromMoneyServer(UUID agentId, UUID secureSessionID, UUID regionId, string regionSecret)
+        {
+            Hashtable MoneyBalanceRequestParams = new Hashtable();
+            MoneyBalanceRequestParams["agentId"] = agentId.ToString();
+            MoneyBalanceRequestParams["secureSessionId"] = secureSessionID.ToString();
+            MoneyBalanceRequestParams["regionId"] = regionId.ToString();
+            MoneyBalanceRequestParams["secret"] = regionSecret;
+            MoneyBalanceRequestParams["currencySecret"] = ""; // per - region/user currency secret gotten from the money system
+
+            Hashtable MoneyRespData = genericCurrencyXMLRPCRequest(MoneyBalanceRequestParams, "simulatorUserBalanceRequest");
+
+            return MoneyRespData;
+        }
+
+
+        /// <summary>
+        /// Generic XMLRPC client abstraction
+        /// </summary>
+        /// <param name="ReqParams">Hashtable containing parameters to the method</param>
+        /// <param name="method">Method to invoke</param>
+        /// <returns>Hashtable with success=>bool and other values</returns>
+        public Hashtable genericCurrencyXMLRPCRequest(Hashtable ReqParams, string method)
+        {
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(ReqParams);
+            // Send Request
+            XmlRpcResponse MoneyResp;
+            try
+            {
+                XmlRpcRequest BalanceRequestReq = new XmlRpcRequest(method, SendParams);
+                MoneyResp = BalanceRequestReq.Send(m_MoneyAddress, 30000);
+            }
+            catch (WebException ex)
+            {
+                m_log.ErrorFormat(
+                    "[MONEY]: Unable to connect to Money Server {0}.  Exception {1}",
+                    m_MoneyAddress, ex);
+
+                Hashtable ErrorHash = new Hashtable();
+                ErrorHash["success"] = false;
+                ErrorHash["errorMessage"] = "Unable to manage your money at this time. Purchases may be unavailable";
+                ErrorHash["errorURI"] = "";
+
+                return ErrorHash;
+                //throw (ex);
+            }
+            catch (SocketException ex)
+            {
+                m_log.ErrorFormat(
+                    "[MONEY]: Unable to connect to Money Server {0}.  Exception {1}",
+                    m_MoneyAddress, ex);
+
+                Hashtable ErrorHash = new Hashtable();
+                ErrorHash["success"] = false;
+                ErrorHash["errorMessage"] = "Unable to manage your money at this time. Purchases may be unavailable";
+                ErrorHash["errorURI"] = "";
+
+                return ErrorHash;
+                //throw (ex);
+            }
+            catch (XmlException ex)
+            {
+                m_log.ErrorFormat(
+                    "[MONEY]: Unable to connect to Money Server {0}.  Exception {1}",
+                    m_MoneyAddress, ex);
+
+                Hashtable ErrorHash = new Hashtable();
+                ErrorHash["success"] = false;
+                ErrorHash["errorMessage"] = "Unable to manage your money at this time. Purchases may be unavailable";
+                ErrorHash["errorURI"] = "";
+
+                return ErrorHash;
+            }
+            if (MoneyResp.IsFault)
+            {
+                Hashtable ErrorHash = new Hashtable();
+                ErrorHash["success"] = false;
+                ErrorHash["errorMessage"] = "Unable to manage your money at this time. Purchases may be unavailable";
+                ErrorHash["errorURI"] = "";
+
+                return ErrorHash;
+            }
+            Hashtable MoneyRespData = (Hashtable) MoneyResp.Value;
+
+            return MoneyRespData;
+        }
+
+        /// <summary>
+        /// This informs the Money Grid Server that the avatar is in this simulator
+        /// </summary>
+        /// <param name="agentId"></param>
+        /// <param name="secureSessionID"></param>
+        /// <param name="regionId"></param>
+        /// <param name="regionSecret"></param>
+        /// <returns></returns>
+        public Hashtable claim_user(UUID agentId, UUID secureSessionID, UUID regionId, string regionSecret)
+        {
+            Hashtable MoneyBalanceRequestParams = new Hashtable();
+            MoneyBalanceRequestParams["agentId"] = agentId.ToString();
+            MoneyBalanceRequestParams["secureSessionId"] = secureSessionID.ToString();
+            MoneyBalanceRequestParams["regionId"] = regionId.ToString();
+            MoneyBalanceRequestParams["secret"] = regionSecret;
+
+            Hashtable MoneyRespData = genericCurrencyXMLRPCRequest(MoneyBalanceRequestParams, "simulatorClaimUserRequest");
+            IClientAPI sendMoneyBal = LocateClientObject(agentId);
+            if (sendMoneyBal != null)
+            {
+                SendMoneyBalance(sendMoneyBal, agentId, sendMoneyBal.SessionId, UUID.Zero);
+            }
+            return MoneyRespData;
+        }
+
+        private SceneObjectPart findPrim(UUID objectID)
+        {
+            lock (m_scenel)
+            {
+                foreach (Scene s in m_scenel.Values)
+                {
+                    SceneObjectPart part = s.GetSceneObjectPart(objectID);
+                    if (part != null)
+                    {
+                        return part;
+                    }
+                }
+            }
+            return null;
+        }
+
+        private string resolveObjectName(UUID objectID)
+        {
+            SceneObjectPart part = findPrim(objectID);
+            if (part != null)
+            {
+                return part.Name;
+            }
+            return String.Empty;
+        }
+
+        private string resolveAgentName(UUID agentID)
+        {
+            // try avatar username surname
+            Scene scene = GetRandomScene();
+            CachedUserInfo profile = scene.CommsManager.UserProfileCacheService.GetUserDetails(agentID);
+            if (profile != null && profile.UserProfile != null)
+            {
+                string avatarname = profile.UserProfile.FirstName + " " + profile.UserProfile.SurName;
+                return avatarname;
+            }
+            else
+            {
+                m_log.ErrorFormat(
+                    "[MONEY]: Could not resolve user {0}", 
+                    agentID);
+            }
+            
+            return String.Empty;
+        }
+
+        private void BalanceUpdate(UUID senderID, UUID receiverID, bool transactionresult, string description)
+        {
+            IClientAPI sender = LocateClientObject(senderID);
+            IClientAPI receiver = LocateClientObject(receiverID);
+
+            if (senderID != receiverID)
+            {
+                if (sender != null)
+                {
+                    sender.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(description), GetFundsForAgentID(senderID));
+                }
+
+                if (receiver != null)
+                {
+                    receiver.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(description), GetFundsForAgentID(receiverID));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Informs the Money Grid Server of a transfer.
+        /// </summary>
+        /// <param name="sourceId"></param>
+        /// <param name="destId"></param>
+        /// <param name="amount"></param>
+        /// <returns></returns>
+        public bool TransferMoneyonMoneyServer(UUID sourceId, UUID destId, int amount, int transactiontype, string description)
+        {
+            int aggregatePermInventory = 0;
+            int aggregatePermNextOwner = 0;
+            int flags = 0;
+            bool rvalue = false;
+
+            IClientAPI cli = LocateClientObject(sourceId);
+            if (cli != null)
+            {
+                Scene userScene = null;
+                lock (m_rootAgents)
+                {
+                    userScene = GetSceneByUUID(m_rootAgents[sourceId]);
+                }
+                if (userScene != null)
+                {
+                    Hashtable ht = new Hashtable();
+                    ht["agentId"] = sourceId.ToString();
+                    ht["secureSessionId"] = cli.SecureSessionId.ToString();
+                    ht["regionId"] = userScene.RegionInfo.originRegionID.ToString();
+                    ht["secret"] = userScene.RegionInfo.regionSecret;
+                    ht["currencySecret"] = " ";
+                    ht["destId"] = destId.ToString();
+                    ht["cash"] = amount;
+                    ht["aggregatePermInventory"] = aggregatePermInventory;
+                    ht["aggregatePermNextOwner"] = aggregatePermNextOwner;
+                    ht["flags"] = flags;
+                    ht["transactionType"] = transactiontype;
+                    ht["description"] = description;
+
+                    Hashtable hresult = genericCurrencyXMLRPCRequest(ht, "regionMoveMoney");
+
+                    if ((bool) hresult["success"] == true)
+                    {
+                        int funds1 = 0;
+                        int funds2 = 0;
+                        try
+                        {
+                            funds1 = (Int32) hresult["funds"];
+                        }
+                        catch (InvalidCastException)
+                        {
+                            funds1 = 0;
+                        }
+                        SetLocalFundsForAgentID(sourceId, funds1);
+                        if (m_KnownClientFunds.ContainsKey(destId))
+                        {
+                            try
+                            {
+                                funds2 = (Int32) hresult["funds2"];
+                            }
+                            catch (InvalidCastException)
+                            {
+                                funds2 = 0;
+                            }
+                            SetLocalFundsForAgentID(destId, funds2);
+                        }
+
+
+                        rvalue = true;
+                    }
+                    else
+                    {
+                        cli.SendAgentAlertMessage((string) hresult["errorMessage"], true);
+                    }
+                }
+            }
+            else
+            {
+                m_log.ErrorFormat("[MONEY]: Client {0} not found", sourceId.ToString());
+            }
+
+            return rvalue;
+        }
+
+        public int GetRemoteBalance(UUID agentId)
+        {
+            int funds = 0;
+
+            IClientAPI aClient = LocateClientObject(agentId);
+            if (aClient != null)
+            {
+                Scene s = LocateSceneClientIn(agentId);
+                if (s != null)
+                {
+                    if (m_MoneyAddress.Length > 0)
+                    {
+                        Hashtable hbinfo =
+                            GetBalanceForUserFromMoneyServer(aClient.AgentId, aClient.SecureSessionId, s.RegionInfo.originRegionID,
+                                                             s.RegionInfo.regionSecret);
+                        if ((bool) hbinfo["success"] == true)
+                        {
+                            try
+                            {
+                                funds = (Int32) hbinfo["funds"];
+                            }
+                            catch (ArgumentException)
+                            {
+                            }
+                            catch (FormatException)
+                            {
+                            }
+                            catch (OverflowException)
+                            {
+                                m_log.ErrorFormat("[MONEY]: While getting the Currency for user {0}, the return funds overflowed.", agentId);
+                                aClient.SendAlertMessage("Unable to get your money balance, money operations will be unavailable");
+                            }
+                            catch (InvalidCastException)
+                            {
+                                funds = 0;
+                            }
+                        }
+                        else
+                        {
+                            m_log.WarnFormat("[MONEY]: Getting Money for user {0} failed with the following message:{1}", agentId,
+                                             (string) hbinfo["errorMessage"]);
+                            aClient.SendAlertMessage((string) hbinfo["errorMessage"]);
+                        }
+                    }
+
+                    SetLocalFundsForAgentID(agentId, funds);
+                    SendMoneyBalance(aClient, agentId, aClient.SessionId, UUID.Zero);
+                }
+                else
+                {
+                    m_log.Debug("[MONEY]: Got balance request update for agent that is here, but couldn't find which scene.");
+                }
+            }
+            else
+            {
+                m_log.Debug("[MONEY]: Got balance request update for agent that isn't here.");
+            }
+            return funds;
+        }
+
+        public XmlRpcResponse GridMoneyUpdate(XmlRpcRequest request)
+        {
+            m_log.Debug("[MONEY]: Dynamic balance update called.");
+            Hashtable requestData = (Hashtable) request.Params[0];
+
+            if (requestData.ContainsKey("agentId"))
+            {
+                UUID agentId = UUID.Zero;
+
+                UUID.TryParse((string) requestData["agentId"], out agentId);
+                if (agentId != UUID.Zero)
+                {
+                    GetRemoteBalance(agentId);
+                }
+                else
+                {
+                    m_log.Debug("[MONEY]: invalid agentId specified, dropping.");
+                }
+            }
+            else
+            {
+                m_log.Debug("[MONEY]: no agentId specified, dropping.");
+            }
+            XmlRpcResponse r = new XmlRpcResponse();
+            Hashtable rparms = new Hashtable();
+            rparms["success"] = true;
+
+            r.Value = rparms;
+            return r;
+        }
+
+        /// <summary>
+        /// XMLRPC handler to send alert message and sound to client
+        /// </summary>
+        public XmlRpcResponse UserAlert(XmlRpcRequest request)
+        {
+            XmlRpcResponse ret = new XmlRpcResponse();
+            Hashtable retparam = new Hashtable();
+            Hashtable requestData = (Hashtable) request.Params[0];
+
+            UUID agentId;
+            UUID soundId;
+            UUID regionId;
+
+            UUID.TryParse((string) requestData["agentId"], out agentId);
+            UUID.TryParse((string) requestData["soundId"], out soundId);
+            UUID.TryParse((string) requestData["regionId"], out regionId);
+            string text = (string) requestData["text"];
+            string secret = (string) requestData["secret"];
+
+            Scene userScene = GetSceneByUUID(regionId);
+            if (userScene != null)
+            {
+                if (userScene.RegionInfo.regionSecret == secret)
+                {
+
+                    IClientAPI client = LocateClientObject(agentId);
+                       if (client != null)
+                       {
+
+                           if (soundId != UUID.Zero)
+                               client.SendPlayAttachedSound(soundId, UUID.Zero, UUID.Zero, 1.0f, 0);
+
+                           client.SendBlueBoxMessage(UUID.Zero, "", text);
+
+                           retparam.Add("success", true);
+                       }
+                    else
+                    {
+                        retparam.Add("success", false);
+                    }
+                }
+                else
+                {
+                    retparam.Add("success", false);
+                }
+            }
+
+            ret.Value = retparam;
+            return ret;
+        }
+
+        # region Standalone box enablers only
+
+        public XmlRpcResponse quote_func(XmlRpcRequest request)
+        {
+            Hashtable requestData = (Hashtable) request.Params[0];
+            UUID agentId = UUID.Zero;
+            int amount = 0;
+            Hashtable quoteResponse = new Hashtable();
+            XmlRpcResponse returnval = new XmlRpcResponse();
+
+            if (requestData.ContainsKey("agentId") && requestData.ContainsKey("currencyBuy"))
+            {
+                UUID.TryParse((string) requestData["agentId"], out agentId);
+                try
+                {
+                    amount = (Int32) requestData["currencyBuy"];
+                }
+                catch (InvalidCastException)
+                {
+                }
+                Hashtable currencyResponse = new Hashtable();
+                currencyResponse.Add("estimatedCost", 0);
+                currencyResponse.Add("currencyBuy", amount);
+
+                quoteResponse.Add("success", true);
+                quoteResponse.Add("currency", currencyResponse);
+                quoteResponse.Add("confirm", "asdfad9fj39ma9fj");
+
+                returnval.Value = quoteResponse;
+                return returnval;
+            }
+
+
+            quoteResponse.Add("success", false);
+            quoteResponse.Add("errorMessage", "Invalid parameters passed to the quote box");
+            quoteResponse.Add("errorURI", "http://www.opensimulator.org/wiki");
+            returnval.Value = quoteResponse;
+            return returnval;
+        }
+
+        public XmlRpcResponse buy_func(XmlRpcRequest request)
+        {
+            Hashtable requestData = (Hashtable) request.Params[0];
+            UUID agentId = UUID.Zero;
+            int amount = 0;
+            if (requestData.ContainsKey("agentId") && requestData.ContainsKey("currencyBuy"))
+            {
+                UUID.TryParse((string) requestData["agentId"], out agentId);
+                try
+                {
+                    amount = (Int32) requestData["currencyBuy"];
+                }
+                catch (InvalidCastException)
+                {
+                }
+                if (agentId != UUID.Zero)
+                {
+                    lock (m_KnownClientFunds)
+                    {
+                        if (m_KnownClientFunds.ContainsKey(agentId))
+                        {
+                            m_KnownClientFunds[agentId] += amount;
+                        }
+                        else
+                        {
+                            m_KnownClientFunds.Add(agentId, amount);
+                        }
+                    }
+                    IClientAPI client = LocateClientObject(agentId);
+                    if (client != null)
+                    {
+                        SendMoneyBalance(client, agentId, client.SessionId, UUID.Zero);
+                    }
+                }
+            }
+            XmlRpcResponse returnval = new XmlRpcResponse();
+            Hashtable returnresp = new Hashtable();
+            returnresp.Add("success", true);
+            returnval.Value = returnresp;
+            return returnval;
+        }
+
+        public XmlRpcResponse preflightBuyLandPrep_func(XmlRpcRequest request)
+        {
+            XmlRpcResponse ret = new XmlRpcResponse();
+            Hashtable retparam = new Hashtable();
+            Hashtable membershiplevels = new Hashtable();
+            ArrayList levels = new ArrayList();
+            Hashtable level = new Hashtable();
+            level.Add("id", "00000000-0000-0000-0000-000000000000");
+            level.Add("description", "some level");
+            levels.Add(level);
+            //membershiplevels.Add("levels",levels);
+
+            Hashtable landuse = new Hashtable();
+            landuse.Add("upgrade", false);
+            landuse.Add("action", "http://invaliddomaininvalid.com/");
+
+            Hashtable currency = new Hashtable();
+            currency.Add("estimatedCost", 0);
+
+            Hashtable membership = new Hashtable();
+            membershiplevels.Add("upgrade", false);
+            membershiplevels.Add("action", "http://invaliddomaininvalid.com/");
+            membershiplevels.Add("levels", membershiplevels);
+
+            retparam.Add("success", true);
+            retparam.Add("currency", currency);
+            retparam.Add("membership", membership);
+            retparam.Add("landuse", landuse);
+            retparam.Add("confirm", "asdfajsdkfjasdkfjalsdfjasdf");
+
+            ret.Value = retparam;
+
+            return ret;
+        }
+
+        public XmlRpcResponse landBuy_func(XmlRpcRequest request)
+        {
+            XmlRpcResponse ret = new XmlRpcResponse();
+            Hashtable retparam = new Hashtable();
+            Hashtable requestData = (Hashtable) request.Params[0];
+
+            UUID agentId = UUID.Zero;
+            int amount = 0;
+            if (requestData.ContainsKey("agentId") && requestData.ContainsKey("currencyBuy"))
+            {
+                UUID.TryParse((string) requestData["agentId"], out agentId);
+                try
+                {
+                    amount = (Int32) requestData["currencyBuy"];
+                }
+                catch (InvalidCastException)
+                {
+                }
+                if (agentId != UUID.Zero)
+                {
+                    lock (m_KnownClientFunds)
+                    {
+                        if (m_KnownClientFunds.ContainsKey(agentId))
+                        {
+                            m_KnownClientFunds[agentId] += amount;
+                        }
+                        else
+                        {
+                            m_KnownClientFunds.Add(agentId, amount);
+                        }
+                    }
+                    IClientAPI client = LocateClientObject(agentId);
+                    if (client != null)
+                    {
+                        SendMoneyBalance(client, agentId, client.SessionId, UUID.Zero);
+                    }
+                }
+            }
+            retparam.Add("success", true);
+            ret.Value = retparam;
+
+            return ret;
+        }
+
+        #endregion
+
+        #region local Fund Management
+
+        /// <summary>
+        /// Ensures that the agent accounting data is set up in this instance.
+        /// </summary>
+        /// <param name="agentID"></param>
+        private void CheckExistAndRefreshFunds(UUID agentID)
+        {
+            lock (m_KnownClientFunds)
+            {
+                if (!m_KnownClientFunds.ContainsKey(agentID))
+                {
+                    m_KnownClientFunds.Add(agentID, m_stipend);
+                }
+                else
+                {
+                    if (m_KnownClientFunds[agentID] <= m_minFundsBeforeRefresh)
+                    {
+                        m_KnownClientFunds[agentID] = m_stipend;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the amount of Funds for an agent
+        /// </summary>
+        /// <param name="AgentID"></param>
+        /// <returns></returns>
+        private int GetFundsForAgentID(UUID AgentID)
+        {
+            int returnfunds = 0;
+            lock (m_KnownClientFunds)
+            {
+                if (m_KnownClientFunds.ContainsKey(AgentID))
+                {
+                    returnfunds = m_KnownClientFunds[AgentID];
+                }
+                else
+                {
+                    //throw new Exception("Unable to get funds.");
+                }
+            }
+            return returnfunds;
+        }
+
+        private void SetLocalFundsForAgentID(UUID AgentID, int amount)
+        {
+            lock (m_KnownClientFunds)
+            {
+                if (m_KnownClientFunds.ContainsKey(AgentID))
+                {
+                    m_KnownClientFunds[AgentID] = amount;
+                }
+                else
+                {
+                    m_KnownClientFunds.Add(AgentID, amount);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Utility Helpers
+
+        /// <summary>
+        /// Locates a IClientAPI for the client specified
+        /// </summary>
+        /// <param name="AgentID"></param>
+        /// <returns></returns>
+        private IClientAPI LocateClientObject(UUID AgentID)
+        {
+            ScenePresence tPresence = null;
+            IClientAPI rclient = null;
+
+            lock (m_scenel)
+            {
+                foreach (Scene _scene in m_scenel.Values)
+                {
+                    tPresence = _scene.GetScenePresence(AgentID);
+                    if (tPresence != null)
+                    {
+                        if (!tPresence.IsChildAgent)
+                        {
+                            rclient = tPresence.ControllingClient;
+                        }
+                    }
+                    if (rclient != null)
+                    {
+                        return rclient;
+                    }
+                }
+            }
+            return null;
+        }
+
+        private Scene LocateSceneClientIn(UUID AgentId)
+        {
+            lock (m_scenel)
+            {
+                foreach (Scene _scene in m_scenel.Values)
+                {
+                    ScenePresence tPresence = _scene.GetScenePresence(AgentId);
+                    if (tPresence != null)
+                    {
+                        if (!tPresence.IsChildAgent)
+                        {
+                            return _scene;
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Utility function Gets a Random scene in the instance.  For when which scene exactly you're doing something with doesn't matter
+        /// </summary>
+        /// <returns></returns>
+        public Scene GetRandomScene()
+        {
+            lock (m_scenel)
+            {
+                foreach (Scene rs in m_scenel.Values)
+                    return rs;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Utility function to get a Scene by RegionID in a module
+        /// </summary>
+        /// <param name="RegionID"></param>
+        /// <returns></returns>
+        public Scene GetSceneByUUID(UUID RegionID)
+        {
+            lock (m_scenel)
+            {
+                foreach (Scene rs in m_scenel.Values)
+                {
+                    if (rs.RegionInfo.originRegionID == RegionID)
+                    {
+                        return rs;
+                    }
+                }
+            }
+            return null;
+        }
+
+        #endregion
+
+        #region event Handlers
+
+        public void requestPayPrice(IClientAPI client, UUID objectID)
+        {
+            Scene scene = LocateSceneClientIn(client.AgentId);
+            if (scene == null)
+                return;
+
+            SceneObjectPart task = scene.GetSceneObjectPart(objectID);
+            if (task == null)
+                return;
+            SceneObjectGroup group = task.ParentGroup;
+            SceneObjectPart root = group.RootPart;
+
+            client.SendPayPrice(objectID, root.PayPrice);
+        }
+
+        /// <summary>
+        /// When the client closes the connection we remove their accounting info from memory to free up resources.
+        /// </summary>
+        /// <param name="AgentID"></param>
+        public void ClientClosed(UUID AgentID)
+        {
+            lock (m_KnownClientFunds)
+            {
+                if (m_keepMoneyAcrossLogins && m_MoneyAddress.Length == 0)
+                {
+                }
+                else
+                {
+                    m_KnownClientFunds.Remove(AgentID);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Event called Economy Data Request handler.
+        /// </summary>
+        /// <param name="agentId"></param>
+        public void EconomyDataRequestHandler(UUID agentId)
+        {
+            IClientAPI user = LocateClientObject(agentId);
+
+            if (user != null)
+            {
+                user.SendEconomyData(EnergyEfficiency, ObjectCapacity, ObjectCount, PriceEnergyUnit, PriceGroupCreate,
+                                     PriceObjectClaim, PriceObjectRent, PriceObjectScaleFactor, PriceParcelClaim, PriceParcelClaimFactor,
+                                     PriceParcelRent, PricePublicObjectDecay, PricePublicObjectDelete, PriceRentLight, PriceUpload,
+                                     TeleportMinPrice, TeleportPriceExponent);
+            }
+        }
+
+        private void ValidateLandBuy(Object osender, EventManager.LandBuyArgs e)
+        {
+            if (m_MoneyAddress.Length == 0)
+            {
+                lock (m_KnownClientFunds)
+                {
+                    if (m_KnownClientFunds.ContainsKey(e.agentId))
+                    {
+                        // Does the sender have enough funds to give?
+                        if (m_KnownClientFunds[e.agentId] >= e.parcelPrice)
+                        {
+                            lock (e)
+                            {
+                                e.economyValidated = true;
+                            }
+                        }
+                    }
+                }
+            }
+            else
+            {
+                if (GetRemoteBalance(e.agentId) >= e.parcelPrice)
+                {
+                    lock (e)
+                    {
+                        e.economyValidated = true;
+                    }
+                }
+            }
+        }
+
+        private void processLandBuy(Object osender, EventManager.LandBuyArgs e)
+        {
+            lock (e)
+            {
+                if (e.economyValidated == true && e.transactionID == 0)
+                {
+                    e.transactionID = Util.UnixTimeSinceEpoch();
+
+                    if (doMoneyTransfer(e.agentId, e.parcelOwnerID, e.parcelPrice, 0, "Land purchase"))
+                    {
+                        lock (e)
+                        {
+                            e.amountDebited = e.parcelPrice;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// THis method gets called when someone pays someone else as a gift.
+        /// </summary>
+        /// <param name="osender"></param>
+        /// <param name="e"></param>
+        private void MoneyTransferAction(Object osender, EventManager.MoneyTransferArgs e)
+        {
+            IClientAPI sender = null;
+            IClientAPI receiver = null;
+
+            if (m_MoneyAddress.Length > 0) // Handled on server
+                e.description = String.Empty;
+
+            if (e.transactiontype == 5008) // Object gets paid
+            {
+                sender = LocateClientObject(e.sender);
+                if (sender != null)
+                {
+                    SceneObjectPart part = findPrim(e.receiver);
+                    if (part == null)
+                        return;
+
+                    string name = resolveAgentName(part.OwnerID);
+                    if (name == String.Empty)
+                        name = "(hippos)";
+
+                    receiver = LocateClientObject(part.OwnerID);
+
+                    string description = String.Format("Paid {0} via object {1}", name, e.description);
+                    bool transactionresult = doMoneyTransfer(e.sender, part.OwnerID, e.amount, e.transactiontype, description);
+
+                    if (transactionresult)
+                    {
+                        ObjectPaid handlerOnObjectPaid = OnObjectPaid;
+                        if (handlerOnObjectPaid != null)
+                        {
+                            handlerOnObjectPaid(e.receiver, e.sender, e.amount);
+                        }
+                    }
+
+                    if (e.sender != e.receiver)
+                    {
+                        sender.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(e.description), GetFundsForAgentID(e.sender));
+                    }
+                    if (receiver != null)
+                    {
+                        receiver.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(e.description), GetFundsForAgentID(part.OwnerID));
+                    }
+                }
+                return;
+            }
+
+            sender = LocateClientObject(e.sender);
+            if (sender != null)
+            {
+                receiver = LocateClientObject(e.receiver);
+
+                bool transactionresult = doMoneyTransfer(e.sender, e.receiver, e.amount, e.transactiontype, e.description);
+
+                if (e.sender != e.receiver)
+                {
+                    if (sender != null)
+                    {
+                        sender.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(e.description), GetFundsForAgentID(e.sender));
+                    }
+                }
+
+                if (receiver != null)
+                {
+                    receiver.SendMoneyBalance(UUID.Random(), transactionresult, Utils.StringToBytes(e.description), GetFundsForAgentID(e.receiver));
+                }
+            }
+            else
+            {
+                m_log.Warn("[MONEY]: Potential Fraud Warning, got money transfer request for avatar that isn't in this simulator - Details; Sender:" +
+                           e.sender.ToString() + " Receiver: " + e.receiver.ToString() + " Amount: " + e.amount.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Event Handler for when a root agent becomes a child agent
+        /// </summary>
+        /// <param name="avatar"></param>
+        private void MakeChildAgent(ScenePresence avatar)
+        {
+            lock (m_rootAgents)
+            {
+                if (m_rootAgents.ContainsKey(avatar.UUID))
+                {
+                    if (m_rootAgents[avatar.UUID] == avatar.Scene.RegionInfo.originRegionID)
+                    {
+                        m_rootAgents.Remove(avatar.UUID);
+//                        m_log.Debug("[MONEY]: Removing " + avatar.Firstname + " " + avatar.Lastname + " as a root agent");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Event Handler for when the client logs out.
+        /// </summary>
+        /// <param name="AgentId"></param>
+        private void ClientLoggedOut(UUID AgentId)
+        {
+            lock (m_rootAgents)
+            {
+                if (m_rootAgents.ContainsKey(AgentId))
+                {
+                    m_rootAgents.Remove(AgentId);
+                    //m_log.Info("[MONEY]: Removing " + AgentId + ". Agent logged out.");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Call this when the client disconnects.
+        /// </summary>
+        /// <param name="client"></param>
+        public void ClientClosed(IClientAPI client)
+        {
+            ClientClosed(client.AgentId);
+        }
+
+        /// <summary>
+        /// Event Handler for when an Avatar enters one of the parcels in the simulator.
+        /// </summary>
+        /// <param name="avatar"></param>
+        /// <param name="localLandID"></param>
+        /// <param name="regionID"></param>
+        private void AvatarEnteringParcel(ScenePresence avatar, int localLandID, UUID regionID)
+        {
+            lock (m_rootAgents)
+            {
+                if (m_rootAgents.ContainsKey(avatar.UUID))
+                {
+                    if (avatar.Scene.RegionInfo.originRegionID != m_rootAgents[avatar.UUID])
+                    {
+                        m_rootAgents[avatar.UUID] = avatar.Scene.RegionInfo.originRegionID;
+
+
+                        //m_log.Info("[MONEY]: Claiming " + avatar.Firstname + " " + avatar.Lastname + " in region:" + avatar.RegionHandle + ".");
+                        // Claim User! my user!  Mine mine mine!
+                        if (m_MoneyAddress.Length > 0)
+                        {
+                            Scene RegionItem = GetSceneByUUID(regionID);
+                            if (RegionItem != null)
+                            {
+                                Hashtable hresult =
+                                    claim_user(avatar.UUID, avatar.ControllingClient.SecureSessionId, regionID, RegionItem.RegionInfo.regionSecret);
+                                if ((bool)hresult["success"] == true)
+                                {
+                                    int funds = 0;
+                                    try
+                                    {
+                                        funds = (Int32)hresult["funds"];
+                                    }
+                                    catch (InvalidCastException)
+                                    {
+                                    }
+                                    SetLocalFundsForAgentID(avatar.UUID, funds);
+                                }
+                                else
+                                {
+                                    avatar.ControllingClient.SendAgentAlertMessage((string)hresult["errorMessage"], true);
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        ILandObject obj = avatar.Scene.LandChannel.GetLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
+                        if ((obj.landData.Flags & (uint)Parcel.ParcelFlags.AllowDamage) != 0)
+                        {
+                            avatar.Invulnerable = false;
+                        }
+                        else
+                        {
+                            avatar.Invulnerable = true;
+                        }
+                    }
+                }
+                else
+                {
+                    lock (m_rootAgents)
+                    {
+                        m_rootAgents.Add(avatar.UUID, avatar.Scene.RegionInfo.originRegionID);
+                    }
+                    if (m_MoneyAddress.Length > 0)
+                    {
+                        Scene RegionItem = GetSceneByUUID(regionID);
+                        if (RegionItem != null)
+                        {
+                            Hashtable hresult = claim_user(avatar.UUID, avatar.ControllingClient.SecureSessionId, regionID, RegionItem.RegionInfo.regionSecret);
+                            if ((bool) hresult["success"] == true)
+                            {
+                                int funds = 0;
+                                try
+                                {
+                                    funds = (Int32) hresult["funds"];
+                                }
+                                catch (InvalidCastException)
+                                {
+                                }
+                                SetLocalFundsForAgentID(avatar.UUID, funds);
+                            }
+                            else
+                            {
+                                avatar.ControllingClient.SendAgentAlertMessage((string) hresult["errorMessage"], true);
+                            }
+                        }
+                    }
+
+                    //m_log.Info("[MONEY]: Claiming " + avatar.Firstname + " " + avatar.Lastname + " in region:" + avatar.RegionHandle + ".");
+                }
+            }
+            //m_log.Info("[FRIEND]: " + avatar.Name + " status:" + (!avatar.IsChildAgent).ToString());
+        }
+
+        public int GetBalance(IClientAPI client)
+        {
+            GetClientFunds(client);
+
+            lock (m_KnownClientFunds)
+            {
+                if (!m_KnownClientFunds.ContainsKey(client.AgentId))
+                    return 0;
+
+                return m_KnownClientFunds[client.AgentId];
+            }
+        }
+
+        // Please do not refactor these to be just one method
+        // Existing implementations need the distinction
+        //
+        public bool UploadCovered(IClientAPI client)
+        {
+            return AmountCovered(client, PriceUpload);
+        }
+
+        public bool GroupCreationCovered(IClientAPI client)
+        {
+            return AmountCovered(client, PriceGroupCreate);
+        }
+
+        public bool AmountCovered(IClientAPI client, int amount)
+        {
+            if (GetBalance(client) < amount)
+                return false;
+            return true;
+        }
+
+        #endregion
+
+        public void ObjectBuy(IClientAPI remoteClient, UUID agentID,
+                UUID sessionID, UUID groupID, UUID categoryID,
+                uint localID, byte saleType, int salePrice)
+        {
+            GetClientFunds(remoteClient);
+
+            if (!m_KnownClientFunds.ContainsKey(remoteClient.AgentId))
+            {
+                remoteClient.SendAgentAlertMessage("Unable to buy now. Your account balance was not found.", false);
+                return;
+            }
+
+            int funds = m_KnownClientFunds[remoteClient.AgentId];
+
+            if (salePrice != 0 && funds < salePrice)
+            {
+                remoteClient.SendAgentAlertMessage("Unable to buy now. You don't have sufficient funds.", false);
+                return;
+            }
+
+            Scene s = LocateSceneClientIn(remoteClient.AgentId);
+
+            SceneObjectPart part = s.GetSceneObjectPart(localID);
+            if (part == null)
+            {
+                remoteClient.SendAgentAlertMessage("Unable to buy now. The object was not found.", false);
+                return;
+            }
+
+            if (s.PerformObjectBuy(remoteClient, categoryID, localID, saleType))
+                doMoneyTransfer(remoteClient.AgentId, part.OwnerID, salePrice, 5000, "Object buy");
+        }
+    }
+
+    public enum TransactionType : int
+    {
+        SystemGenerated = 0,
+        RegionMoneyRequest = 1,
+        Gift = 2,
+        Purchase = 3
+    }
+
+  
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs b/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs
new file mode 100644
index 0000000..7326373
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Dialog/DialogModule.cs
@@ -0,0 +1,143 @@
+/*
+ * 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 OpenSim 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.Collections.Generic;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.Dialog
+{
+    public class DialogModule : IRegionModule, IDialogModule
+    { 
+        //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        protected Scene m_scene;
+        
+        public void Initialise(Scene scene, IConfigSource source)
+        {
+            m_scene = scene;
+            m_scene.RegisterModuleInterface<IDialogModule>(this);
+        }
+        
+        public void PostInitialise() {}
+        public void Close() {}
+        public string Name { get { return "Dialog Module"; } }
+        public bool IsSharedModule { get { return false; } }
+        
+        public void SendAlertToUser(IClientAPI client, string message)
+        {
+            SendAlertToUser(client, message, false);
+        }          
+        
+        public void SendAlertToUser(IClientAPI client, string message, bool modal)
+        {
+            client.SendAgentAlertMessage(message, modal);
+        } 
+        
+        public void SendAlertToUser(UUID agentID, string message)
+        {
+            SendAlertToUser(agentID, message, false);
+        }          
+        
+        public void SendAlertToUser(UUID agentID, string message, bool modal)
+        {
+            ScenePresence sp = m_scene.GetScenePresence(agentID);
+            
+            if (sp != null)
+                sp.ControllingClient.SendAgentAlertMessage(message, modal);
+        }           
+        
+        public void SendAlertToUser(string firstName, string lastName, string message, bool modal)
+        {
+            List<ScenePresence> presenceList = m_scene.GetScenePresences();
+
+            foreach (ScenePresence presence in presenceList)
+            {
+                if (presence.Firstname == firstName && presence.Lastname == lastName)
+                {
+                    presence.ControllingClient.SendAgentAlertMessage(message, modal);
+                    break;
+                }
+            }
+        }     
+        
+        public void SendGeneralAlert(string message)
+        {
+            List<ScenePresence> presenceList = m_scene.GetScenePresences();
+
+            foreach (ScenePresence presence in presenceList)
+            {
+                if (!presence.IsChildAgent)
+                    presence.ControllingClient.SendAlertMessage(message);
+            }
+        }    
+        
+        public void SendDialogToUser(
+            UUID avatarID, string objectName, UUID objectID, UUID ownerID, 
+            string message, UUID textureID, int ch, string[] buttonlabels)
+        {
+            ScenePresence sp = m_scene.GetScenePresence(avatarID);
+            
+            if (sp != null)
+                sp.ControllingClient.SendDialog(objectName, objectID, ownerID, message, textureID, ch, buttonlabels);
+        }        
+
+        public void SendUrlToUser(
+            UUID avatarID, string objectName, UUID objectID, UUID ownerID, bool groupOwned, string message, string url)
+        {
+            ScenePresence sp = m_scene.GetScenePresence(avatarID);
+            
+            if (sp != null)            
+                sp.ControllingClient.SendLoadURL(objectName, objectID, ownerID, groupOwned, message, url);
+        }        
+        
+        public void SendNotificationToUsersInEstate(
+            UUID fromAvatarID, string fromAvatarName, string message)
+        {
+            // TODO: This does not yet do what it says on the tin - it only sends the message to users in the same
+            // region as the sending avatar.
+            SendNotificationToUsersInRegion(fromAvatarID, fromAvatarName, message);
+        }        
+        
+        public void SendNotificationToUsersInRegion(
+            UUID fromAvatarID, string fromAvatarName, string message)
+        {        
+            List<ScenePresence> presenceList = m_scene.GetScenePresences();
+
+            foreach (ScenePresence presence in presenceList)
+            {
+                if (!presence.IsChildAgent)
+                    presence.ControllingClient.SendBlueBoxMessage(fromAvatarID, fromAvatarName, message);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Friends/FriendsModule.cs b/OpenSim/Region/CoreModules/Avatar/Friends/FriendsModule.cs
new file mode 100644
index 0000000..fb4d08a
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Friends/FriendsModule.cs
@@ -0,0 +1,1003 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications.Cache;
+using OpenSim.Framework.Servers;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.Friends
+{
+    /*
+        This module handles adding/removing friends, and the the presence
+        notification process for login/logoff of friends.
+
+        The presence notification works as follows:
+        - After the user initially connects to a region (so we now have a UDP
+          connection to work with), this module fetches the friends of user
+          (those are cached), their on-/offline status, and info about the
+          region they are in from the MessageServer.
+        - (*) It then informs the user about the on-/offline status of her friends.
+        - It then informs all online friends currently on this region-server about
+          user's new online status (this will save some network traffic, as local
+          messages don't have to be transferred inter-region, and it will be all
+          that has to be done in Standalone Mode).
+        - For the rest of the online friends (those not on this region-server),
+          this module uses the provided region-information to map users to
+          regions, and sends one notification to every region containing the
+          friends to inform on that server.
+        - The region-server will handle that in the following way:
+          - If it finds the friend, it informs her about the user being online.
+          - If it doesn't find the friend (maybe she TPed away in the meantime),
+            it stores that information.
+          - After it processed all friends, it returns the list of friends it
+            couldn't find.
+        - If this list isn't empty, the FriendsModule re-requests information
+          about those online friends that have been missed and starts at (*)
+          again until all friends have been found, or until it tried 3 times
+          (to prevent endless loops due to some uncaught error).
+
+        NOTE: Online/Offline notifications don't need to be sent on region change.
+
+        We implement two XMLRpc handlers here, handling all the inter-region things
+        we have to handle:
+        - On-/Offline-Notifications (bulk)
+        - Terminate Friendship messages (single)
+     */
+
+    public class FriendsModule : IRegionModule, IFriendsModule
+    {
+        private class Transaction
+        {
+            public UUID agentID;
+            public string agentName;
+            public uint count;
+
+            public Transaction(UUID agentID, string agentName)
+            {
+                this.agentID = agentID;
+                this.agentName = agentName;
+                this.count = 1;
+            }
+        }
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Cache m_friendLists = new Cache(CacheFlags.AllowUpdate);
+
+        private Dictionary<UUID, ulong> m_rootAgents = new Dictionary<UUID, ulong>();
+
+        private Dictionary<UUID, UUID> m_pendingCallingcardRequests = new Dictionary<UUID,UUID>();
+
+        private Scene m_initialScene; // saves a lookup if we don't have a specific scene
+        private Dictionary<ulong, Scene> m_scenes = new Dictionary<ulong,Scene>();
+        private IMessageTransferModule m_TransferModule = null;
+
+        #region IRegionModule Members
+
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            lock (m_scenes)
+            {
+                if (m_scenes.Count == 0)
+                {
+                    scene.CommsManager.HttpServer.AddXmlRPCHandler("presence_update_bulk", processPresenceUpdateBulk);
+                    scene.CommsManager.HttpServer.AddXmlRPCHandler("terminate_friend", processTerminateFriend);
+                    m_friendLists.DefaultTTL = new TimeSpan(1, 0, 0);  // store entries for one hour max
+                    m_initialScene = scene;
+                }
+
+                if (!m_scenes.ContainsKey(scene.RegionInfo.RegionHandle))
+                    m_scenes[scene.RegionInfo.RegionHandle] = scene;
+            }
+            
+            scene.RegisterModuleInterface<IFriendsModule>(this);
+            
+            scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
+            scene.EventManager.OnAvatarEnteringNewParcel += AvatarEnteringParcel;
+            scene.EventManager.OnMakeChildAgent += MakeChildAgent;
+            scene.EventManager.OnClientClosed += ClientClosed;
+        }
+
+        public void PostInitialise()
+        {
+            if (m_scenes.Count > 0)
+            {
+                m_TransferModule = m_initialScene.RequestModuleInterface<IMessageTransferModule>();
+            }
+            if (m_TransferModule == null)
+                m_log.Error("[FRIENDS]: Unable to find a message transfer module, friendship offers will not work");
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "FriendsModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Receive presence information changes about clients in other regions.
+        /// </summary>
+        /// <param name="req"></param>
+        /// <returns></returns>
+        public XmlRpcResponse processPresenceUpdateBulk(XmlRpcRequest req)
+        {
+            Hashtable requestData = (Hashtable)req.Params[0];
+
+            List<UUID> friendsNotHere = new List<UUID>();
+
+            // this is called with the expectation that all the friends in the request are on this region-server.
+            // But as some time passed since we checked (on the other region-server, via the MessagingServer),
+            // some of the friends might have teleported away.
+            // Actually, even now, between this line and the sending below, some people could TP away. So,
+            // we'll have to lock the m_rootAgents list for the duration to prevent/delay that.
+            lock (m_rootAgents)
+            {
+                List<ScenePresence> friendsHere = new List<ScenePresence>();
+                
+                try
+                {
+                    UUID agentID = new UUID((string)requestData["agentID"]);
+                    bool agentOnline = (bool)requestData["agentOnline"];
+                    int count = (int)requestData["friendCount"];
+                    for (int i = 0; i < count; ++i)
+                    {
+                        UUID uuid;
+                        if (UUID.TryParse((string)requestData["friendID_" + i], out uuid))
+                        {
+                            if (m_rootAgents.ContainsKey(uuid)) friendsHere.Add(GetRootPresenceFromAgentID(uuid));
+                            else friendsNotHere.Add(uuid);
+                        }
+                    }
+
+                    // now send, as long as they are still here...
+                    UUID[] agentUUID = new UUID[] { agentID };
+                    if (agentOnline)
+                    {
+                        foreach (ScenePresence agent in friendsHere)
+                        {
+                            agent.ControllingClient.SendAgentOnline(agentUUID);
+                        }
+                    }
+                    else
+                    {
+                        foreach (ScenePresence agent in friendsHere)
+                        {
+                            agent.ControllingClient.SendAgentOffline(agentUUID);
+                        }
+                    }
+                }
+                catch(Exception e)
+                {
+                    m_log.Warn("[FRIENDS]: Got exception while parsing presence_update_bulk request:", e);
+                }
+            }
+
+            // no need to lock anymore; if TPs happen now, worst case is that we have an additional agent in this region,
+            // which should be caught on the next iteration...
+            Hashtable result = new Hashtable();
+            int idx = 0;
+            foreach (UUID uuid in friendsNotHere)
+            {
+                result["friendID_" + idx++] = uuid.ToString();
+            }
+            result["friendCount"] = idx;
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = result;
+
+            return response;
+        }
+
+        public XmlRpcResponse processTerminateFriend(XmlRpcRequest req)
+        {
+            Hashtable requestData = (Hashtable)req.Params[0];
+
+            bool success = false;
+
+            UUID agentID;
+            UUID friendID;
+            if (requestData.ContainsKey("agentID") && UUID.TryParse((string)requestData["agentID"], out agentID) &&
+                requestData.ContainsKey("friendID") && UUID.TryParse((string)requestData["friendID"], out friendID))
+            {
+                // try to find it and if it is there, prevent it to vanish before we sent the message
+                lock (m_rootAgents)
+                {
+                    if (m_rootAgents.ContainsKey(agentID))
+                    {
+                        m_log.DebugFormat("[FRIEND]: Sending terminate friend {0} to agent {1}", friendID, agentID);
+                        GetRootPresenceFromAgentID(agentID).ControllingClient.SendTerminateFriend(friendID);
+                        success = true;
+                    }
+                }
+            }
+
+            // return whether we were successful
+            Hashtable result = new Hashtable();
+            result["success"] = success;
+
+            XmlRpcResponse response = new XmlRpcResponse();
+            response.Value = result;
+            return response;
+        }
+
+        private void OnNewClient(IClientAPI client)
+        {
+            // All friends establishment protocol goes over instant message
+            // There's no way to send a message from the sim
+            // to a user to 'add a friend' without causing dialog box spam
+
+            // Subscribe to instant messages
+            client.OnInstantMessage += OnInstantMessage;
+
+            // Friend list management
+            client.OnApproveFriendRequest += OnApproveFriendRequest;
+            client.OnDenyFriendRequest += OnDenyFriendRequest;
+            client.OnTerminateFriendship += OnTerminateFriendship;
+
+            // ... calling card handling...
+            client.OnOfferCallingCard += OnOfferCallingCard;
+            client.OnAcceptCallingCard += OnAcceptCallingCard;
+            client.OnDeclineCallingCard += OnDeclineCallingCard;
+
+            // we need this one exactly once per agent session (see comments in the handler below)
+            client.OnEconomyDataRequest += OnEconomyDataRequest;
+
+            // if it leaves, we want to know, too
+            client.OnLogout += OnLogout;
+        }
+
+        private void ClientClosed(UUID AgentId)
+        {
+            // agent's client was closed. As we handle logout in OnLogout, this here has only to handle
+            // TPing away (root agent is closed) or TPing/crossing in a region far enough away (client
+            // agent is closed).
+            // NOTE: In general, this doesn't mean that the agent logged out, just that it isn't around
+            // in one of the regions here anymore.
+            lock (m_rootAgents)
+            {
+                if (m_rootAgents.ContainsKey(AgentId))
+                {
+                    m_rootAgents.Remove(AgentId);
+                }
+            }
+        }
+
+        private void AvatarEnteringParcel(ScenePresence avatar, int localLandID, UUID regionID)
+        {
+            lock (m_rootAgents)
+            {
+                m_rootAgents[avatar.UUID] = avatar.RegionHandle;
+                // Claim User! my user!  Mine mine mine!
+            }
+        }
+
+        private void MakeChildAgent(ScenePresence avatar)
+        {
+            lock (m_rootAgents)
+            {
+                if (m_rootAgents.ContainsKey(avatar.UUID))
+                {
+                    // only delete if the region matches. As this is a shared module, the avatar could be
+                    // root agent in another region on this server.
+                    if (m_rootAgents[avatar.UUID] == avatar.RegionHandle)
+                    {
+                        m_rootAgents.Remove(avatar.UUID);
+//                        m_log.Debug("[FRIEND]: Removing " + avatar.Firstname + " " + avatar.Lastname + " as a root agent");
+                    }
+                }
+            }
+        }
+
+        private ScenePresence GetRootPresenceFromAgentID(UUID AgentID)
+        {
+            ScenePresence returnAgent = null;
+            lock (m_scenes)
+            {
+                ScenePresence queryagent = null;
+                foreach (Scene scene in m_scenes.Values)
+                {
+                    queryagent = scene.GetScenePresence(AgentID);
+                    if (queryagent != null)
+                    {
+                        if (!queryagent.IsChildAgent)
+                        {
+                            returnAgent = queryagent;
+                            break;
+                        }
+                    }
+                }
+            }
+            return returnAgent;
+        }
+
+        private ScenePresence GetAnyPresenceFromAgentID(UUID AgentID)
+        {
+            ScenePresence returnAgent = null;
+            lock (m_scenes)
+            {
+                ScenePresence queryagent = null;
+                foreach (Scene scene in m_scenes.Values)
+                {
+                    queryagent = scene.GetScenePresence(AgentID);
+                    if (queryagent != null)
+                    {
+                        returnAgent = queryagent;
+                        break;
+                    }
+                }
+            }
+            return returnAgent;
+        }
+        
+        public void OfferFriendship(UUID fromUserId, IClientAPI toUserClient, string offerMessage)
+        {
+            CachedUserInfo userInfo = m_initialScene.CommsManager.UserProfileCacheService.GetUserDetails(fromUserId);
+                
+            if (userInfo != null)
+            {
+                GridInstantMessage msg = new GridInstantMessage(
+                    toUserClient.Scene, fromUserId, userInfo.UserProfile.Name, toUserClient.AgentId,
+                    (byte)InstantMessageDialog.FriendshipOffered, offerMessage, false, Vector3.Zero); 
+            
+                FriendshipOffered(msg);
+            }
+            else
+            {
+                m_log.ErrorFormat("[FRIENDS]: No user found for id {0} in OfferFriendship()", fromUserId);
+            }
+        }        
+
+        #region FriendRequestHandling
+
+        private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
+        {
+            // Friend Requests go by Instant Message..    using the dialog param
+            // https://wiki.secondlife.com/wiki/ImprovedInstantMessage
+
+            if (im.dialog == (byte)InstantMessageDialog.FriendshipOffered) // 38
+            {
+                // fromAgentName is the *destination* name (the friend we offer friendship to)                
+                ScenePresence initiator = GetAnyPresenceFromAgentID(new UUID(im.fromAgentID));
+                im.fromAgentName = initiator != null ? initiator.Name : "(hippo)";
+                
+                FriendshipOffered(im);
+            }
+            else if (im.dialog == (byte)InstantMessageDialog.FriendshipAccepted) // 39
+            {
+                FriendshipAccepted(client, im);
+            }
+            else if (im.dialog == (byte)InstantMessageDialog.FriendshipDeclined) // 40
+            {
+                FriendshipDeclined(client, im);
+            }
+        }
+        
+        /// <summary>
+        /// Invoked when a user offers a friendship.
+        /// </summary>
+        /// 
+        /// <param name="im"></param>    
+        /// <param name="client"></param>
+        private void FriendshipOffered(GridInstantMessage im)
+        {
+            // this is triggered by the initiating agent:
+            // A local agent offers friendship to some possibly remote friend.
+            // A IM is triggered, processed here and sent to the friend (possibly in a remote region).           
+
+            m_log.DebugFormat("[FRIEND]: Offer(38) - From: {0}, FromName: {1} To: {2}, Session: {3}, Message: {4}, Offline {5}",
+                       im.fromAgentID, im.fromAgentName, im.toAgentID, im.imSessionID, im.message, im.offline);
+
+            // 1.20 protocol sends an UUID in the message field, instead of the friendship offer text.
+            // For interoperability, we have to clear that
+            if (Util.isUUID(im.message)) im.message = "";
+
+            // be sneeky and use the initiator-UUID as transactionID. This means we can be stateless.
+            // we have to look up the agent name on friendship-approval, though.
+            im.imSessionID = im.fromAgentID;
+
+            if (m_TransferModule != null)
+            {
+                // Send it to whoever is the destination.
+                // If new friend is local, it will send an IM to the viewer.
+                // If new friend is remote, it will cause a OnGridInstantMessage on the remote server
+                m_TransferModule.SendInstantMessage(
+                    im,
+                    delegate(bool success) 
+                    {
+                        m_log.DebugFormat("[FRIEND]: sending IM success = {0}", success);
+                    }
+                );
+            }            
+        }
+        
+        /// <summary>
+        /// Invoked when a user accepts a friendship offer.
+        /// </summary>
+        /// <param name="im"></param>
+        /// <param name="client"></param>
+        private void FriendshipAccepted(IClientAPI client, GridInstantMessage im)
+        {
+            m_log.DebugFormat("[FRIEND]: 39 - from client {0}, agent {2} {3}, imsession {4} to {5}: {6} (dialog {7})",
+              client.AgentId, im.fromAgentID, im.fromAgentName, im.imSessionID, im.toAgentID, im.message, im.dialog);            
+        }
+        
+        /// <summary>
+        /// Invoked when a user declines a friendship offer.
+        /// </summary>
+        /// May not currently be used - see OnDenyFriendRequest() instead
+        /// <param name="im"></param>
+        /// <param name="client"></param>
+        private void FriendshipDeclined(IClientAPI client, GridInstantMessage im)
+        {
+            UUID fromAgentID = new UUID(im.fromAgentID);
+            UUID toAgentID = new UUID(im.toAgentID);
+            
+            // declining the friendship offer causes a type 40 IM being sent to the (possibly remote) initiator
+            // toAgentID is initiator, fromAgentID declined friendship
+            m_log.DebugFormat("[FRIEND]: 40 - from client {0}, agent {1} {2}, imsession {3} to {4}: {5} (dialog {6})",
+              client != null ? client.AgentId.ToString() : "<null>",
+              fromAgentID, im.fromAgentName, im.imSessionID, im.toAgentID, im.message, im.dialog);
+
+            // Send the decline to whoever is the destination.
+            GridInstantMessage msg 
+                = new GridInstantMessage(
+                    client.Scene, fromAgentID, client.Name, toAgentID,
+                    im.dialog, im.message, im.offline != 0, im.Position);
+            
+            // If new friend is local, it will send an IM to the viewer.
+            // If new friend is remote, it will cause a OnGridInstantMessage on the remote server
+            m_TransferModule.SendInstantMessage(msg,
+                delegate(bool success) {
+                    m_log.DebugFormat("[FRIEND]: sending IM success = {0}", success);
+                }
+            );            
+        }
+
+        private void OnGridInstantMessage(GridInstantMessage msg)
+        {
+            // This event won't be raised unless we have that agent,
+            // so we can depend on the above not trying to send
+            // via grid again
+            m_log.DebugFormat("[FRIEND]: Got GridIM from {0}, to {1}, imSession {2}, message {3}, dialog {4}",
+                              msg.fromAgentID, msg.toAgentID, msg.imSessionID, msg.message, msg.dialog);
+            
+            if (msg.dialog == (byte)InstantMessageDialog.FriendshipOffered ||
+                msg.dialog == (byte)InstantMessageDialog.FriendshipAccepted ||
+                msg.dialog == (byte)InstantMessageDialog.FriendshipDeclined)
+            {
+                // this should succeed as we *know* the root agent is here.
+                m_TransferModule.SendInstantMessage(msg,
+                    delegate(bool success) {
+                        m_log.DebugFormat("[FRIEND]: sending IM success = {0}", success);
+                    }
+                );
+            }
+
+            if (msg.dialog == (byte)InstantMessageDialog.FriendshipAccepted)
+            {
+                // for accept friendship, we have to do a bit more
+                ApproveFriendship(new UUID(msg.fromAgentID), new UUID(msg.toAgentID), msg.fromAgentName);
+            }
+        }
+
+        private void ApproveFriendship(UUID fromAgentID, UUID toAgentID, string fromName)
+        {
+            m_log.DebugFormat("[FRIEND]: Approve friendship from {0} (ID: {1}) to {2}",
+                              fromAgentID, fromName, toAgentID);
+
+            // a new friend was added in the initiator's and friend's data, so the cache entries are wrong now.
+            lock (m_friendLists)
+            {
+                m_friendLists.Invalidate(fromAgentID);
+                m_friendLists.Invalidate(toAgentID);
+            }
+
+            // now send presence update and add a calling card for the new friend
+
+            ScenePresence initiator = GetAnyPresenceFromAgentID(toAgentID);
+            if (initiator == null)
+            {
+                // quite wrong. Shouldn't happen.
+                m_log.WarnFormat("[FRIEND]: Coudn't find initiator of friend request {0}", toAgentID);
+                return;
+            }
+
+            m_log.DebugFormat("[FRIEND]: Tell {0} that {1} is online",
+                              initiator.Name, fromName);
+            // tell initiator that friend is online
+            initiator.ControllingClient.SendAgentOnline(new UUID[] { fromAgentID });
+
+            // find the folder for the friend...
+            InventoryFolderImpl folder =
+                initiator.Scene.CommsManager.UserProfileCacheService.GetUserDetails(toAgentID).FindFolderForType((int)InventoryType.CallingCard);
+            if (folder != null)
+            {
+                // ... and add the calling card
+                CreateCallingCard(initiator.ControllingClient, fromAgentID, folder.ID, fromName);
+            }
+        }
+
+        private void OnApproveFriendRequest(IClientAPI client, UUID agentID, UUID friendID, List<UUID> callingCardFolders)
+        {
+            m_log.DebugFormat("[FRIEND]: Got approve friendship from {0} {1}, agentID {2}, tid {3}",
+                              client.Name, client.AgentId, agentID, friendID);
+
+            // store the new friend persistently for both avatars
+            m_initialScene.StoreAddFriendship(friendID, agentID, (uint) FriendRights.CanSeeOnline);
+
+            // The cache entries aren't valid anymore either, as we just added a friend to both sides.
+            lock (m_friendLists)
+            {
+                m_friendLists.Invalidate(agentID);
+                m_friendLists.Invalidate(friendID);
+            }
+
+            // if it's a local friend, we don't have to do the lookup
+            ScenePresence friendPresence = GetAnyPresenceFromAgentID(friendID);
+
+            if (friendPresence != null)
+            {
+                m_log.Debug("[FRIEND]: Local agent detected.");
+
+                // create calling card
+                CreateCallingCard(client, friendID, callingCardFolders[0], friendPresence.Name);
+
+                // local message means OnGridInstantMessage won't be triggered, so do the work here.
+                friendPresence.ControllingClient.SendInstantMessage(agentID, agentID.ToString(), friendID, client.Name,
+                                                                    (byte)InstantMessageDialog.FriendshipAccepted,
+                                                                    (uint)Util.UnixTimeSinceEpoch());
+                ApproveFriendship(agentID, friendID, client.Name);
+            }
+            else
+            {
+                m_log.Debug("[FRIEND]: Remote agent detected.");
+
+                // fetch the friend's name for the calling card.
+                CachedUserInfo info = m_initialScene.CommsManager.UserProfileCacheService.GetUserDetails(friendID);
+
+                // create calling card
+                CreateCallingCard(client, friendID, callingCardFolders[0],
+                                  info.UserProfile.FirstName + " " + info.UserProfile.SurName);
+
+                // Compose (remote) response to friend.
+                GridInstantMessage msg = new GridInstantMessage(client.Scene, agentID, client.Name, friendID,
+                                                                (byte)InstantMessageDialog.FriendshipAccepted,
+                                                                agentID.ToString(), false, Vector3.Zero);
+                if (m_TransferModule != null)
+                {
+                    m_TransferModule.SendInstantMessage(msg,
+                        delegate(bool success) {
+                            m_log.DebugFormat("[FRIEND]: sending IM success = {0}", success);
+                        }
+                    );
+                }
+            }
+
+            // tell client that new friend is online
+            client.SendAgentOnline(new UUID[] { friendID });
+        }
+
+        private void OnDenyFriendRequest(IClientAPI client, UUID agentID, UUID friendID, List<UUID> callingCardFolders)
+        {
+            m_log.DebugFormat("[FRIEND]: Got deny friendship from {0} {1}, agentID {2}, tid {3}",
+                              client.Name, client.AgentId, agentID, friendID);
+
+            // Compose response to other agent.
+            GridInstantMessage msg = new GridInstantMessage(client.Scene, agentID, client.Name, friendID,
+                                                            (byte)InstantMessageDialog.FriendshipDeclined,
+                                                            agentID.ToString(), false, Vector3.Zero);
+            // send decline to initiator
+            if (m_TransferModule != null)
+            {
+                m_TransferModule.SendInstantMessage(msg,
+                    delegate(bool success) {
+                        m_log.DebugFormat("[FRIEND]: sending IM success = {0}", success);
+                    }
+                );
+            }
+        }
+
+        private void OnTerminateFriendship(IClientAPI client, UUID agentID, UUID exfriendID)
+        {
+            // client.AgentId == agentID!
+
+            // this removes the friends from the stored friendlists. After the next login, they will be gone...
+            m_initialScene.StoreRemoveFriendship(agentID, exfriendID);
+
+            // ... now tell the two involved clients that they aren't friends anymore.
+
+            // I don't know why we have to tell <agent>, as this was caused by her, but that's how it works in SL...
+            client.SendTerminateFriend(exfriendID);
+
+            // now send the friend, if online
+            ScenePresence presence = GetAnyPresenceFromAgentID(exfriendID);
+            if (presence != null)
+            {
+                m_log.DebugFormat("[FRIEND]: Sending terminate friend {0} to agent {1}", agentID, exfriendID);
+                presence.ControllingClient.SendTerminateFriend(agentID);
+            }
+            else
+            {
+                // retry 3 times, in case the agent TPed from the last known region...
+                for (int retry = 0; retry < 3; ++retry)
+                {
+                    // wasn't sent, so ex-friend wasn't around on this region-server. Fetch info and try to send
+                    UserAgentData data = m_initialScene.CommsManager.UserService.GetAgentByUUID(exfriendID);
+                    
+                    if (null == data)
+                        break;
+                    
+                    if (!data.AgentOnline)
+                    {
+                        m_log.DebugFormat("[FRIEND]: {0} is offline, so not sending TerminateFriend", exfriendID);
+                        break; // if ex-friend isn't online, we don't need to send
+                    }
+
+                    m_log.DebugFormat("[FRIEND]: Sending remote terminate friend {0} to agent {1}@{2}",
+                                      agentID, exfriendID, data.Handle);
+
+                    // try to send to foreign region, retry if it fails (friend TPed away, for example)
+                    if (m_initialScene.TriggerTerminateFriend(data.Handle, exfriendID, agentID)) break;
+                }
+            }
+
+            // clean up cache: FriendList is wrong now...
+            lock (m_friendLists)
+            {
+                m_friendLists.Invalidate(agentID);
+                m_friendLists.Invalidate(exfriendID);
+            }
+        }
+
+        #endregion
+
+        #region CallingCards
+
+        private void OnOfferCallingCard(IClientAPI client, UUID destID, UUID transactionID)
+        {
+            m_log.DebugFormat("[CALLING CARD]: got offer from {0} for {1}, transaction {2}",
+                              client.AgentId, destID, transactionID);
+            // This might be slightly wrong. On a multi-region server, we might get the child-agent instead of the root-agent
+            // (or the root instead of the child)
+            ScenePresence destAgent = GetAnyPresenceFromAgentID(destID);
+            if (destAgent == null)
+            {
+                client.SendAlertMessage("The person you have offered a card to can't be found anymore.");
+                return;
+            }
+
+            lock (m_pendingCallingcardRequests)
+            {
+                m_pendingCallingcardRequests[transactionID] = client.AgentId;
+            }
+            // inform the destination agent about the offer
+            destAgent.ControllingClient.SendOfferCallingCard(client.AgentId, transactionID);
+        }
+
+        private void CreateCallingCard(IClientAPI client, UUID creator, UUID folder, string name)
+        {
+            InventoryItemBase item = new InventoryItemBase();
+            item.AssetID = UUID.Zero;
+            item.AssetType = (int)AssetType.CallingCard;
+            item.BasePermissions = (uint)PermissionMask.Copy;
+            item.CreationDate = Util.UnixTimeSinceEpoch();
+            item.Creator = creator;
+            item.CurrentPermissions = item.BasePermissions;
+            item.Description = "";
+            item.EveryOnePermissions = (uint)PermissionMask.None;
+            item.Flags = 0;
+            item.Folder = folder;
+            item.GroupID = UUID.Zero;
+            item.GroupOwned = false;
+            item.ID = UUID.Random();
+            item.InvType = (int)InventoryType.CallingCard;
+            item.Name = name;
+            item.NextPermissions = item.EveryOnePermissions;
+            item.Owner = client.AgentId;
+            item.SalePrice = 10;
+            item.SaleType = (byte)SaleType.Not;
+            ((Scene)client.Scene).AddInventoryItem(client, item);
+        }
+
+        private void OnAcceptCallingCard(IClientAPI client, UUID transactionID, UUID folderID)
+        {
+            m_log.DebugFormat("[CALLING CARD]: User {0} ({1} {2}) accepted tid {3}, folder {4}",
+                              client.AgentId,
+                              client.FirstName, client.LastName,
+                              transactionID, folderID);
+            UUID destID;
+            lock (m_pendingCallingcardRequests)
+            {
+                if (!m_pendingCallingcardRequests.TryGetValue(transactionID, out destID))
+                {
+                    m_log.WarnFormat("[CALLING CARD]: Got a AcceptCallingCard from {0} without an offer before.",
+                                     client.Name);
+                    return;
+                }
+                // else found pending calling card request with that transaction.
+                m_pendingCallingcardRequests.Remove(transactionID);
+            }
+
+
+            ScenePresence destAgent = GetAnyPresenceFromAgentID(destID);
+            // inform sender of the card that destination declined the offer
+            if (destAgent != null) destAgent.ControllingClient.SendAcceptCallingCard(transactionID);
+
+            // put a calling card into the inventory of receiver
+            CreateCallingCard(client, destID, folderID, destAgent.Name);
+        }
+
+        private void OnDeclineCallingCard(IClientAPI client, UUID transactionID)
+        {
+            m_log.DebugFormat("[CALLING CARD]: User {0} (ID:{1}) declined card, tid {2}",
+                              client.Name, client.AgentId, transactionID);
+            UUID destID;
+            lock (m_pendingCallingcardRequests)
+            {
+                if (!m_pendingCallingcardRequests.TryGetValue(transactionID, out destID))
+                {
+                    m_log.WarnFormat("[CALLING CARD]: Got a AcceptCallingCard from {0} without an offer before.",
+                                     client.Name);
+                    return;
+                }
+                // else found pending calling card request with that transaction.
+                m_pendingCallingcardRequests.Remove(transactionID);
+            }
+
+            ScenePresence destAgent = GetAnyPresenceFromAgentID(destID);
+            // inform sender of the card that destination declined the offer
+            if (destAgent != null) destAgent.ControllingClient.SendDeclineCallingCard(transactionID);
+        }
+
+        /// <summary>
+        /// Send presence information about a client to other clients in both this region and others.
+        /// </summary>
+        /// <param name="client"></param>
+        /// <param name="friendList"></param>
+        /// <param name="iAmOnline"></param>
+        private void SendPresenceState(IClientAPI client, List<FriendListItem> friendList, bool iAmOnline)
+        {
+            //m_log.DebugFormat("[FRIEND]: {0} logged {1}; sending presence updates", client.Name, iAmOnline ? "in" : "out");
+
+            if (friendList == null || friendList.Count == 0)
+            {
+                //m_log.DebugFormat("[FRIEND]: {0} doesn't have friends.", client.Name);
+                return; // nothing we can do if she doesn't have friends...
+            }
+
+            // collect sets of friendIDs; to send to (online and offline), and to receive from
+            // TODO: If we ever switch to .NET >= 3, replace those Lists with HashSets.
+            // I can't believe that we have Dictionaries, but no Sets, considering Java introduced them years ago...
+            List<UUID> friendIDsToSendTo = new List<UUID>();
+            List<UUID> candidateFriendIDsToReceive = new List<UUID>();
+            
+            foreach (FriendListItem item in friendList)
+            {
+                if (((item.FriendListOwnerPerms | item.FriendPerms) & (uint)FriendRights.CanSeeOnline) != 0)
+                {
+                    // friend is allowed to see my presence => add
+                    if ((item.FriendListOwnerPerms & (uint)FriendRights.CanSeeOnline) != 0) 
+                        friendIDsToSendTo.Add(item.Friend);
+
+                    if ((item.FriendPerms & (uint)FriendRights.CanSeeOnline) != 0) 
+                        candidateFriendIDsToReceive.Add(item.Friend);
+                }
+            }
+
+            // we now have a list of "interesting" friends (which we have to find out on-/offline state for),
+            // friends we want to send our online state to (if *they* are online, too), and
+            // friends we want to receive online state for (currently unknown whether online or not)
+
+            // as this processing might take some time and friends might TP away, we try up to three times to
+            // reach them. Most of the time, we *will* reach them, and this loop won't loop
+            int retry = 0;
+            do
+            {
+                // build a list of friends to look up region-information and on-/offline-state for
+                List<UUID> friendIDsToLookup = new List<UUID>(friendIDsToSendTo);
+                foreach (UUID uuid in candidateFriendIDsToReceive)
+                {
+                    if (!friendIDsToLookup.Contains(uuid)) friendIDsToLookup.Add(uuid);
+                }
+
+                m_log.DebugFormat(
+                    "[FRIEND]: {0} to lookup, {1} to send to, {2} candidates to receive from for agent {3}",
+                    friendIDsToLookup.Count, friendIDsToSendTo.Count, candidateFriendIDsToReceive.Count, client.Name);
+
+                // we have to fetch FriendRegionInfos, as the (cached) FriendListItems don't
+                // necessarily contain the correct online state...
+                Dictionary<UUID, FriendRegionInfo> friendRegions = m_initialScene.GetFriendRegionInfos(friendIDsToLookup);
+                m_log.DebugFormat(
+                    "[FRIEND]: Found {0} regionInfos for {1} friends of {2}",
+                    friendRegions.Count, friendIDsToLookup.Count, client.Name);
+
+                // argument for SendAgentOn/Offline; we shouldn't generate that repeatedly within loops.
+                UUID[] agentArr = new UUID[] { client.AgentId };
+
+                // first, send to friend presence state to me, if I'm online...
+                if (iAmOnline)
+                {
+                    List<UUID> friendIDsToReceive = new List<UUID>();
+                    
+                    for (int i = candidateFriendIDsToReceive.Count - 1; i >= 0; --i)
+                    {
+                        UUID uuid = candidateFriendIDsToReceive[i];
+                        FriendRegionInfo info;
+                        if (friendRegions.TryGetValue(uuid, out info) && info != null && info.isOnline)
+                        {
+                            friendIDsToReceive.Add(uuid);
+                        }
+                    }
+                    
+                    m_log.DebugFormat(
+                        "[FRIEND]: Sending {0} online friends to {1}", friendIDsToReceive.Count, client.Name);
+                    
+                    if (friendIDsToReceive.Count > 0) 
+                        client.SendAgentOnline(friendIDsToReceive.ToArray());
+
+                    // clear them for a possible second iteration; we don't have to repeat this
+                    candidateFriendIDsToReceive.Clear();
+                }
+
+                // now, send my presence state to my friends
+                for (int i = friendIDsToSendTo.Count - 1; i >= 0; --i)
+                {
+                    UUID uuid = friendIDsToSendTo[i];
+                    FriendRegionInfo info;
+                    if (friendRegions.TryGetValue(uuid, out info) && info != null && info.isOnline)
+                    {
+                        // any client is good enough, root or child...
+                        ScenePresence agent = GetAnyPresenceFromAgentID(uuid);
+                        if (agent != null)
+                        {
+                            m_log.DebugFormat("[FRIEND]: Found local agent {0}", agent.Name);
+
+                            // friend is online and on this server...
+                            if (iAmOnline) agent.ControllingClient.SendAgentOnline(agentArr);
+                            else agent.ControllingClient.SendAgentOffline(agentArr);
+
+                            // done, remove it
+                            friendIDsToSendTo.RemoveAt(i);
+                        }
+                    }
+                    else
+                    {
+                        m_log.DebugFormat("[FRIEND]: Friend {0} ({1}) is offline; not sending.", uuid, i);
+
+                        // friend is offline => no need to try sending
+                        friendIDsToSendTo.RemoveAt(i);
+                    }
+                }
+
+                m_log.DebugFormat("[FRIEND]: Have {0} friends to contact via inter-region comms.", friendIDsToSendTo.Count);
+
+                // we now have all the friends left that are online (we think), but not on this region-server
+                if (friendIDsToSendTo.Count > 0)
+                {
+                    // sort them into regions
+                    Dictionary<ulong, List<UUID>> friendsInRegion = new Dictionary<ulong,List<UUID>>();
+                    foreach (UUID uuid in friendIDsToSendTo)
+                    {
+                        ulong handle = friendRegions[uuid].regionHandle; // this can't fail as we filtered above already
+                        List<UUID> friends;
+                        if (!friendsInRegion.TryGetValue(handle, out friends))
+                        {
+                            friends = new List<UUID>();
+                            friendsInRegion[handle] = friends;
+                        }
+                        friends.Add(uuid);
+                    }
+                    m_log.DebugFormat("[FRIEND]: Found {0} regions to send to.", friendRegions.Count);
+
+                    // clear uuids list and collect missed friends in it for the next retry
+                    friendIDsToSendTo.Clear();
+
+                    // send bulk updates to the region
+                    foreach (KeyValuePair<ulong, List<UUID>> pair in friendsInRegion)
+                    {
+                        m_log.DebugFormat("[FRIEND]: Inform {0} friends in region {1} that user {2} is {3}line",
+                                          pair.Value.Count, pair.Key, client.Name, iAmOnline ? "on" : "off");
+
+                        friendIDsToSendTo.AddRange(m_initialScene.InformFriendsInOtherRegion(client.AgentId, pair.Key, pair.Value, iAmOnline));
+                    }
+                }
+                // now we have in friendIDsToSendTo only the agents left that TPed away while we tried to contact them.
+                // In most cases, it will be empty, and it won't loop here. But sometimes, we have to work harder and try again...
+            }
+            while (++retry < 3 && friendIDsToSendTo.Count > 0);
+        }
+
+        private void OnEconomyDataRequest(UUID agentID)
+        {
+            // KLUDGE: This is the only way I found to get a message (only) after login was completed and the
+            // client is connected enough to receive UDP packets).
+            // This packet seems to be sent only once, just after connection was established to the first
+            // region after login.
+            // We use it here to trigger a presence update; the old update-on-login was never be heard by
+            // the freshly logged in viewer, as it wasn't connected to the region at that time.
+            // TODO: Feel free to replace this by a better solution if you find one.
+
+            // get the agent. This should work every time, as we just got a packet from it
+            //ScenePresence agent = GetRootPresenceFromAgentID(agentID);
+            // KLUDGE 2: As this is sent quite early, the avatar isn't here as root agent yet. So, we have to cheat a bit
+            ScenePresence agent = GetAnyPresenceFromAgentID(agentID);
+
+            // just to be paranoid...
+            if (agent == null)
+            {
+                m_log.ErrorFormat("[FRIEND]: Got a packet from agent {0} who can't be found anymore!?", agentID);
+                return;
+            }
+
+            List<FriendListItem> fl;
+            lock (m_friendLists)
+            {
+                fl = (List<FriendListItem>)m_friendLists.Get(agent.ControllingClient.AgentId,
+                                                             m_initialScene.GetFriendList);
+            }
+
+            // tell everyone that we are online
+            SendPresenceState(agent.ControllingClient, fl, true);
+        }
+
+        private void OnLogout(IClientAPI remoteClient)
+        {
+            List<FriendListItem> fl;
+            lock (m_friendLists)
+            {
+                fl = (List<FriendListItem>)m_friendLists.Get(remoteClient.AgentId,
+                                                             m_initialScene.GetFriendList);
+            }
+
+            // tell everyone that we are offline
+            SendPresenceState(remoteClient, fl, false);
+        }
+    }
+
+    #endregion
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Gestures/GesturesModule.cs b/OpenSim/Region/CoreModules/Avatar/Gestures/GesturesModule.cs
new file mode 100644
index 0000000..a3a642f
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Gestures/GesturesModule.cs
@@ -0,0 +1,104 @@
+/*
+ * 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 OpenSim 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 log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.Communications.Cache;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using System.Reflection;
+
+namespace OpenSim.Region.CoreModules.Avatar.Gestures
+{
+    public class GesturesModule : IRegionModule
+    { 
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        protected Scene m_scene;
+        
+        public void Initialise(Scene scene, IConfigSource source)
+        {
+            m_scene = scene;
+            
+            m_scene.EventManager.OnNewClient += OnNewClient;
+        }
+        
+        public void PostInitialise() {}
+        public void Close() {}
+        public string Name { get { return "Gestures Module"; } }
+        public bool IsSharedModule { get { return false; } }
+        
+        private void OnNewClient(IClientAPI client)
+        {
+            client.OnActivateGesture += ActivateGesture;
+            client.OnDeactivateGesture += DeactivateGesture;
+        }
+        
+        public virtual void ActivateGesture(IClientAPI client, UUID assetId, UUID gestureId)
+        {
+            CachedUserInfo userInfo = m_scene.CommsManager.UserProfileCacheService.GetUserDetails(client.AgentId);
+
+            if (userInfo != null)
+            {
+                InventoryItemBase item = userInfo.RootFolder.FindItem(gestureId);
+                if (item != null)
+                {
+                    item.Flags = 1;
+                    userInfo.UpdateItem(item);
+                }
+                else 
+                    m_log.ErrorFormat(
+                        "[GESTURES]: Unable to find gesture to activate {0} for {1}", gestureId, client.Name);
+            }
+            else 
+                m_log.ErrorFormat("[GESTURES]: Unable to find user {0}", client.Name);
+        }
+
+        public virtual void DeactivateGesture(IClientAPI client, UUID gestureId)
+        {
+            CachedUserInfo userInfo = m_scene.CommsManager.UserProfileCacheService.GetUserDetails(client.AgentId);
+
+            if (userInfo != null)
+            {
+                InventoryItemBase item = userInfo.RootFolder.FindItem(gestureId);
+                if (item != null)
+                {
+                    item.Flags = 0;
+                    userInfo.UpdateItem(item);
+                }
+                else 
+                    m_log.ErrorFormat(
+                        "[GESTURES]: Unable to find gesture to deactivate {0} for {1}", gestureId, client.Name);
+            }
+            else 
+                m_log.ErrorFormat("[GESTURES]: Unable to find user {0}", client.Name);
+        }        
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Avatar/Groups/GroupsModule.cs b/OpenSim/Region/CoreModules/Avatar/Groups/GroupsModule.cs
new file mode 100644
index 0000000..92d0fdd
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Groups/GroupsModule.cs
@@ -0,0 +1,223 @@
+/*
+ * 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 OpenSim 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 OpenMetaverse;
+using log4net;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.Groups
+{
+    public class GroupsModule : IRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Dictionary<UUID, GroupMembershipData> m_GroupMap =
+                new Dictionary<UUID, GroupMembershipData>();
+
+        private Dictionary<UUID, IClientAPI> m_ClientMap =
+                new Dictionary<UUID, IClientAPI>();
+
+        private UUID opensimulatorGroupID =
+                new UUID("00000000-68f9-1111-024e-222222111123");
+
+        private List<Scene> m_SceneList = new List<Scene>();
+
+        private static GroupMembershipData osGroup =
+                new GroupMembershipData();
+
+        #region IRegionModule Members
+
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            IConfig groupsConfig = config.Configs["Groups"];
+
+            if (groupsConfig == null)
+            {
+                m_log.Info("[GROUPS]: No configuration found. Using defaults");
+            }
+            else
+            {
+                if (!groupsConfig.GetBoolean("Enabled", false))
+                {
+                    m_log.Info("[GROUPS]: Groups disabled in configuration");
+                    return;
+                }
+
+                if (groupsConfig.GetString("Module", "Default") != "Default")
+                    return;
+            }
+
+            lock (m_SceneList)
+            {
+                if (!m_SceneList.Contains(scene))
+                {
+                    if (m_SceneList.Count == 0)
+                    {
+                        osGroup.GroupID = opensimulatorGroupID;
+                        osGroup.GroupName = "OpenSimulator Testing";
+                        osGroup.GroupPowers =
+                                (uint)(GroupPowers.AllowLandmark |
+                                GroupPowers.AllowSetHome);
+                        m_GroupMap[opensimulatorGroupID] = osGroup;
+                    }
+                    m_SceneList.Add(scene);
+                }
+            }
+
+            scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnClientClosed += OnClientClosed;
+            scene.EventManager.OnIncomingInstantMessage +=
+                    OnGridInstantMessage;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+//            m_log.Debug("[GROUPS]: Shutting down group module.");
+            
+            lock (m_ClientMap)
+            {
+                m_ClientMap.Clear();
+            }
+
+            lock (m_GroupMap)
+            {
+                m_GroupMap.Clear();
+            }
+        }
+
+        public string Name
+        {
+            get { return "GroupsModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        #endregion
+
+        private void OnNewClient(IClientAPI client)
+        {
+            // Subscribe to instant messages
+            client.OnInstantMessage += OnInstantMessage;
+            client.OnAgentDataUpdateRequest += OnAgentDataUpdateRequest;
+            client.OnUUIDGroupNameRequest += HandleUUIDGroupNameRequest;
+            lock (m_ClientMap)
+            {
+                if (!m_ClientMap.ContainsKey(client.AgentId))
+                {
+                    m_ClientMap.Add(client.AgentId, client);
+                }
+            }
+
+            GroupMembershipData[] updateGroups = new GroupMembershipData[1];
+            updateGroups[0] = osGroup;
+
+            client.SendGroupMembership(updateGroups);
+        }
+
+        private void OnAgentDataUpdateRequest(IClientAPI remoteClient,
+                UUID AgentID, UUID SessionID)
+        {
+            UUID ActiveGroupID;
+            string ActiveGroupName;
+            ulong ActiveGroupPowers;
+
+            string firstname = remoteClient.FirstName;
+            string lastname = remoteClient.LastName;
+
+            string ActiveGroupTitle = "I IZ N0T";
+
+            ActiveGroupID = osGroup.GroupID;
+            ActiveGroupName = osGroup.GroupName;
+            ActiveGroupPowers = osGroup.GroupPowers;
+
+            remoteClient.SendAgentDataUpdate(AgentID, ActiveGroupID, firstname,
+                    lastname, ActiveGroupPowers, ActiveGroupName,
+                    ActiveGroupTitle);
+        }
+
+        private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
+        {
+        }
+
+        private void OnGridInstantMessage(GridInstantMessage msg)
+        {
+            // Trigger the above event handler
+            OnInstantMessage(null, msg);
+        }
+
+        private void HandleUUIDGroupNameRequest(UUID id,IClientAPI remote_client)
+        {
+            string groupnamereply = "Unknown";
+            UUID groupUUID = UUID.Zero;
+
+            lock (m_GroupMap)
+            {
+                if (m_GroupMap.ContainsKey(id))
+                {
+                    GroupMembershipData grp = m_GroupMap[id];
+                    groupnamereply = grp.GroupName;
+                    groupUUID = grp.GroupID;
+                }
+            }
+            remote_client.SendGroupNameReply(groupUUID, groupnamereply);
+        }
+
+        private void OnClientClosed(UUID agentID)
+        {
+            lock (m_ClientMap)
+            {
+                if (m_ClientMap.ContainsKey(agentID))
+                {
+//                    IClientAPI cli = m_ClientMap[agentID];
+//                    if (cli != null)
+//                    {
+//                        //m_log.Info("[GROUPS]: Removing all reference to groups for " + cli.Name);
+//                    }
+//                    else
+//                    {
+//                        //m_log.Info("[GROUPS]: Removing all reference to groups for " + agentID.ToString());
+//                    }
+                    m_ClientMap.Remove(agentID);
+                }
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/InstantMessageModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/InstantMessageModule.cs
new file mode 100644
index 0000000..3ad2c91
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/InstantMessageModule.cs
@@ -0,0 +1,170 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Net;
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Framework.Client;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
+{
+    public class InstantMessageModule : IRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);        
+
+        /// <value>
+        /// Is this module enabled?
+        /// </value>
+        private bool m_enabled = false;
+        
+        private readonly List<Scene> m_scenes = new List<Scene>();
+
+        #region IRegionModule Members
+
+        private IMessageTransferModule m_TransferModule = null;
+
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            if (config.Configs["Messaging"] != null)
+            {
+                if (config.Configs["Messaging"].GetString(
+                        "InstantMessageModule", "InstantMessageModule") !=
+                        "InstantMessageModule")
+                    return;
+            }
+            
+            m_enabled = true;
+
+            lock (m_scenes)
+            {
+                if (!m_scenes.Contains(scene))
+                {
+                    m_scenes.Add(scene);
+                    scene.EventManager.OnClientConnect += OnClientConnect;
+                    scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
+                }
+            }
+        }
+
+        void OnClientConnect(IClientCore client)
+        {
+            IClientIM clientIM;
+            if (client.TryGet(out clientIM))
+            {
+                clientIM.OnInstantMessage += OnInstantMessage;
+            }
+        }
+
+        public void PostInitialise()
+        {
+            if (!m_enabled)
+                return;
+            
+            m_TransferModule =
+                m_scenes[0].RequestModuleInterface<IMessageTransferModule>();
+
+            if (m_TransferModule == null)
+                m_log.Error("[INSTANT MESSAGE]: No message transfer module, "+
+                "IM will not work!");
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "InstantMessageModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        #endregion
+
+        public void OnInstantMessage(IClientAPI client, GridInstantMessage im)
+        {
+            byte dialog = im.dialog;
+
+            if (   dialog != (byte)InstantMessageDialog.MessageFromAgent
+                && dialog != (byte)InstantMessageDialog.StartTyping
+                && dialog != (byte)InstantMessageDialog.StopTyping)
+            {
+                return;
+            }
+
+            if (m_TransferModule != null)
+            {
+                m_TransferModule.SendInstantMessage(im,
+                    delegate(bool success)
+                    {
+                        if (dialog == (uint)InstantMessageDialog.StartTyping ||
+                            dialog == (uint)InstantMessageDialog.StopTyping)
+                        {
+                            return;
+                        }
+
+                        if ((client != null) && !success)
+                        {
+                            client.SendInstantMessage(new UUID(im.toAgentID),
+                                    "Unable to send instant message. "+
+                                    "User is not logged in.",
+                                    new UUID(im.fromAgentID), "System",
+                                    (byte)InstantMessageDialog.BusyAutoResponse,
+                                    (uint)Util.UnixTimeSinceEpoch());
+                        }
+                    }
+                );
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="msg"></param>
+        private void OnGridInstantMessage(GridInstantMessage msg)
+        {
+            // Just call the Text IM handler above
+            // This event won't be raised unless we have that agent,
+            // so we can depend on the above not trying to send
+            // via grid again
+            //
+            OnInstantMessage(null, msg);
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs
new file mode 100644
index 0000000..91c22eb
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs
@@ -0,0 +1,655 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Net;
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Framework.Client;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
+{
+    public class MessageTransferModule : IRegionModule, IMessageTransferModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        // private bool m_Enabled = false;
+        private bool m_Gridmode = false;
+        private List<Scene> m_Scenes = new List<Scene>();
+        private Dictionary<UUID, ulong> m_UserRegionMap = new Dictionary<UUID, ulong>();
+
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            IConfig cnf = config.Configs["Messaging"];
+            if (cnf != null && cnf.GetString(
+                    "MessageTransferModule", "MessageTransferModule") !=
+                    "MessageTransferModule")
+                return;
+
+            cnf = config.Configs["Startup"];
+            if (cnf != null)
+                m_Gridmode = cnf.GetBoolean("gridmode", false);
+
+            // m_Enabled = true;
+
+            lock (m_Scenes)
+            {
+                if (m_Scenes.Count == 0)
+                {
+                    scene.CommsManager.HttpServer.AddXmlRPCHandler(
+                        "grid_instant_message", processXMLRPCGridInstantMessage);
+                }
+
+                scene.RegisterModuleInterface<IMessageTransferModule>(this);
+                m_Scenes.Add(scene);
+            }
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "MessageTransferModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        public void SendInstantMessage(GridInstantMessage im, MessageResultNotification result)
+        {
+            UUID toAgentID = new UUID(im.toAgentID);
+
+            m_log.DebugFormat("[INSTANT MESSAGE]: Attempting delivery of IM from {0} to {1}", im.fromAgentName, toAgentID.ToString());
+
+            // Try root avatar only first
+            foreach (Scene scene in m_Scenes)
+            {
+                if (scene.Entities.ContainsKey(toAgentID) &&
+                        scene.Entities[toAgentID] is ScenePresence)
+                {
+                    m_log.DebugFormat("[INSTANT MESSAGE]: Looking for {0} in {1}", toAgentID.ToString(), scene.RegionInfo.RegionName);
+                    // Local message
+                    ScenePresence user = (ScenePresence) scene.Entities[toAgentID];
+                    if (!user.IsChildAgent)
+                    {
+                        m_log.DebugFormat("[INSTANT MESSAGE]: Delivering to client");
+                        user.ControllingClient.SendInstantMessage(
+                                new UUID(im.fromAgentID),
+                                im.message,
+                                new UUID(im.toAgentID),
+                                im.fromAgentName,
+                                im.dialog,
+                                im.timestamp,
+                                new UUID(im.imSessionID),
+                                im.fromGroup,
+                                im.binaryBucket);
+                        // Message sent
+                        result(true);
+                        return;
+                    }
+                }
+            }
+
+            // try child avatar second
+            foreach (Scene scene in m_Scenes)
+            {
+//                m_log.DebugFormat(
+//                    "[INSTANT MESSAGE]: Looking for child of {0} in {1}", toAgentID, scene.RegionInfo.RegionName);
+
+                if (scene.Entities.ContainsKey(toAgentID) &&
+                        scene.Entities[toAgentID] is ScenePresence)
+                {
+                    // Local message
+                    ScenePresence user = (ScenePresence) scene.Entities[toAgentID];
+
+                    m_log.DebugFormat("[INSTANT MESSAGE]: Delivering to client");
+                    user.ControllingClient.SendInstantMessage(
+                            new UUID(im.fromAgentID),
+                            im.message,
+                            new UUID(im.toAgentID),
+                            im.fromAgentName,
+                            im.dialog,
+                            im.timestamp,
+                            new UUID(im.imSessionID),
+                            im.fromGroup,
+                            im.binaryBucket);
+                    // Message sent
+                    result(true);
+                    return;
+                }
+            }
+
+            if (m_Gridmode)
+            {
+                //m_log.DebugFormat("[INSTANT MESSAGE]: Delivering via grid");
+                // Still here, try send via Grid
+                SendGridInstantMessageViaXMLRPC(im, result);
+                return;
+            }
+
+            //m_log.DebugFormat("[INSTANT MESSAGE]: Undeliverable");
+            result(false);
+            return;
+        }
+
+        /// <summary>
+        /// Process a XMLRPC Grid Instant Message
+        /// </summary>
+        /// <param name="request">XMLRPC parameters
+        /// </param>
+        /// <returns>Nothing much</returns>
+        protected virtual XmlRpcResponse processXMLRPCGridInstantMessage(XmlRpcRequest request)
+        {
+            bool successful = false;
+            
+            // TODO: For now, as IMs seem to be a bit unreliable on OSGrid, catch all exception that
+            // happen here and aren't caught and log them.
+            try 
+            {
+                // various rational defaults
+                UUID fromAgentID = UUID.Zero;
+                UUID toAgentID = UUID.Zero;
+                UUID imSessionID = UUID.Zero;
+                uint timestamp = 0;
+                string fromAgentName = "";
+                string message = "";
+                byte dialog = (byte)0;
+                bool fromGroup = false;
+                byte offline = (byte)0;
+                uint ParentEstateID=0;
+                Vector3 Position = Vector3.Zero;
+                UUID RegionID = UUID.Zero ;
+                byte[] binaryBucket = new byte[0];
+
+                float pos_x = 0;
+                float pos_y = 0;
+                float pos_z = 0;
+                //m_log.Info("Processing IM");
+
+
+                Hashtable requestData = (Hashtable)request.Params[0];
+                // Check if it's got all the data
+                if (requestData.ContainsKey("from_agent_id")
+                        && requestData.ContainsKey("to_agent_id") && requestData.ContainsKey("im_session_id")
+                        && requestData.ContainsKey("timestamp") && requestData.ContainsKey("from_agent_name")
+                        && requestData.ContainsKey("message") && requestData.ContainsKey("dialog")
+                        && requestData.ContainsKey("from_group")
+                        && requestData.ContainsKey("offline") && requestData.ContainsKey("parent_estate_id")
+                        && requestData.ContainsKey("position_x") && requestData.ContainsKey("position_y")
+                        && requestData.ContainsKey("position_z") && requestData.ContainsKey("region_id")
+                        && requestData.ContainsKey("binary_bucket"))
+                {
+                    // Do the easy way of validating the UUIDs
+                    UUID.TryParse((string)requestData["from_agent_id"], out fromAgentID);
+                    UUID.TryParse((string)requestData["to_agent_id"], out toAgentID);
+                    UUID.TryParse((string)requestData["im_session_id"], out imSessionID);
+                    UUID.TryParse((string)requestData["region_id"], out RegionID);
+
+                    try
+                    {
+                        timestamp = (uint)Convert.ToInt32((string)requestData["timestamp"]);
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                    catch (FormatException)
+                    {
+                    }
+                    catch (OverflowException)
+                    {
+                    }
+
+                    fromAgentName = (string)requestData["from_agent_name"];
+                    message = (string)requestData["message"];
+
+                    // Bytes don't transfer well over XMLRPC, so, we Base64 Encode them.
+                    string requestData1 = (string)requestData["dialog"];
+                    if (string.IsNullOrEmpty(requestData1))
+                    {
+                        dialog = 0;
+                    }
+                    else
+                    {
+                        byte[] dialogdata = Convert.FromBase64String(requestData1);
+                        dialog = dialogdata[0];
+                    }
+
+                    if ((string)requestData["from_group"] == "TRUE")
+                        fromGroup = true;
+
+                    string requestData2 = (string)requestData["offline"];
+                    if (String.IsNullOrEmpty(requestData2))
+                    {
+                        offline = 0;
+                    }
+                    else
+                    {
+                        byte[] offlinedata = Convert.FromBase64String(requestData2);
+                        offline = offlinedata[0];
+                    }
+
+                    try
+                    {
+                        ParentEstateID = (uint)Convert.ToInt32((string)requestData["parent_estate_id"]);
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                    catch (FormatException)
+                    {
+                    }
+                    catch (OverflowException)
+                    {
+                    }
+
+                    try
+                    {
+                        pos_x = (uint)Convert.ToInt32((string)requestData["position_x"]);
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                    catch (FormatException)
+                    {
+                    }
+                    catch (OverflowException)
+                    {
+                    }
+                    try
+                    {
+                        pos_y = (uint)Convert.ToInt32((string)requestData["position_y"]);
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                    catch (FormatException)
+                    {
+                    }
+                    catch (OverflowException)
+                    {
+                    }
+                    try
+                    {
+                        pos_z = (uint)Convert.ToInt32((string)requestData["position_z"]);
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                    catch (FormatException)
+                    {
+                    }
+                    catch (OverflowException)
+                    {
+                    }
+
+                    Position = new Vector3(pos_x, pos_y, pos_z);
+
+                    string requestData3 = (string)requestData["binary_bucket"];
+                    if (string.IsNullOrEmpty(requestData3))
+                    {
+                        binaryBucket = new byte[0];
+                    }
+                    else
+                    {
+                        binaryBucket = Convert.FromBase64String(requestData3);
+                    }
+
+                    // Create a New GridInstantMessageObject the the data
+                    GridInstantMessage gim = new GridInstantMessage();
+                    gim.fromAgentID = fromAgentID.Guid;
+                    gim.fromAgentName = fromAgentName;
+                    gim.fromGroup = fromGroup;
+                    gim.imSessionID = imSessionID.Guid;
+                    gim.RegionID = RegionID.Guid;
+                    gim.timestamp = timestamp;
+                    gim.toAgentID = toAgentID.Guid;
+                    gim.message = message;
+                    gim.dialog = dialog;
+                    gim.offline = offline;
+                    gim.ParentEstateID = ParentEstateID;
+                    gim.Position = Position;
+                    gim.binaryBucket = binaryBucket;
+
+
+                    // Trigger the Instant message in the scene.
+                    foreach (Scene scene in m_Scenes)
+                    {
+                        if (scene.Entities.ContainsKey(toAgentID) &&
+                                scene.Entities[toAgentID] is ScenePresence)
+                        {
+                            ScenePresence user =
+                                    (ScenePresence)scene.Entities[toAgentID];
+
+                            if (!user.IsChildAgent)
+                            {
+                                scene.EventManager.TriggerIncomingInstantMessage(gim);
+                                successful = true;
+                            }
+                        }
+                    }
+                    if (!successful)
+                    {
+                        // If the message can't be delivered to an agent, it
+                        // is likely to be a group IM. On a group IM, the
+                        // imSessionID = toAgentID = group id. Raise the
+                        // unhandled IM event to give the groups module
+                        // a chance to pick it up. We raise that in a random
+                        // scene, since the groups module is shared.
+                        //
+                        m_Scenes[0].EventManager.TriggerUnhandledInstantMessage(gim);
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[INSTANT MESSAGE]: Caught unexpected exception:", e);
+                successful = false;
+            }
+
+            //Send response back to region calling if it was successful
+            // calling region uses this to know when to look up a user's location again.
+            XmlRpcResponse resp = new XmlRpcResponse();
+            Hashtable respdata = new Hashtable();
+            if (successful)
+                respdata["success"] = "TRUE";
+            else
+                respdata["success"] = "FALSE";
+            resp.Value = respdata;
+
+            return resp;
+        }
+
+        /// <summary>
+        /// delegate for sending a grid instant message asynchronously
+        /// </summary>
+        public delegate void GridInstantMessageDelegate(GridInstantMessage im, MessageResultNotification result, ulong prevRegionHandle);
+
+        private void GridInstantMessageCompleted(IAsyncResult iar)
+        {
+            GridInstantMessageDelegate icon =
+                    (GridInstantMessageDelegate)iar.AsyncState;
+            icon.EndInvoke(iar);
+        }
+
+
+        protected virtual void SendGridInstantMessageViaXMLRPC(GridInstantMessage im, MessageResultNotification result)
+        {
+            GridInstantMessageDelegate d = SendGridInstantMessageViaXMLRPCAsync;
+
+            d.BeginInvoke(im, result, 0, 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.
+        /// </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, ulong prevRegionHandle)
+        {
+            UUID toAgentID = new UUID(im.toAgentID);
+
+            UserAgentData  upd = null;
+
+            bool lookupAgent = false;
+
+            lock (m_UserRegionMap)
+            {
+                if (m_UserRegionMap.ContainsKey(toAgentID))
+                {
+                    upd = new UserAgentData();
+                    upd.AgentOnline = true;
+                    upd.Handle = m_UserRegionMap[toAgentID];
+
+                    // 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 (prevRegionHandle == upd.Handle)
+                    {
+                        lookupAgent = true;
+                    }
+                }
+                else
+                {
+                    lookupAgent = true;
+                }
+            }
+            
+
+            // Are we needing to look-up an agent?
+            if (lookupAgent)
+            {
+                // Non-cached user agent lookup.
+                upd = m_Scenes[0].CommsManager.UserService.GetAgentByUUID(toAgentID);
+
+                if (upd != null)
+                {
+                    // check if we've tried this before..
+                    // This is one way to end the recursive loop
+                    //
+                    if (upd.Handle == prevRegionHandle)
+                    {
+                        m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
+                        result(false);
+                        return;
+                    }
+                }
+                else
+                {
+                    m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
+                    result(false);
+                    return;
+                }
+            }
+
+            if (upd != null)
+            {
+                if (upd.AgentOnline)
+                {
+                    RegionInfo reginfo = m_Scenes[0].SceneGridService.RequestNeighbouringRegionInfo(upd.Handle);
+                    if (reginfo != null)
+                    {
+                        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.Handle;
+                                }
+                                else
+                                {
+                                    m_UserRegionMap.Add(toAgentID, upd.Handle);
+                                }
+                            }
+                            result(true);
+                        }
+                        else
+                        {
+                            // 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.Handle);
+                        }
+
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("[GRID INSTANT MESSAGE]: Unable to find region {0}", upd.Handle);
+                        result(false);
+                    }
+                }
+                else
+                {
+                    result(false);
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("[GRID INSTANT MESSAGE]: Unable to find user {0}", toAgentID);
+                result(false);
+            }
+
+        }
+
+        /// <summary>
+        /// This actually does the XMLRPC Request
+        /// </summary>
+        /// <param name="reginfo">RegionInfo we pull the data out of to send the request to</param>
+        /// <param name="xmlrpcdata">The Instant Message data Hashtable</param>
+        /// <returns>Bool if the message was successfully delivered at the other side.</returns>
+        private bool doIMSending(RegionInfo reginfo, Hashtable xmlrpcdata)
+        {
+
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(xmlrpcdata);
+            XmlRpcRequest GridReq = new XmlRpcRequest("grid_instant_message", SendParams);
+            try
+            {
+
+                XmlRpcResponse GridResp = GridReq.Send("http://" + reginfo.ExternalHostName + ":" + reginfo.HttpPort, 3000);
+
+                Hashtable responseData = (Hashtable)GridResp.Value;
+
+                if (responseData.ContainsKey("success"))
+                {
+                    if ((string)responseData["success"] == "TRUE")
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            catch (WebException e)
+            {
+                m_log.ErrorFormat("[GRID INSTANT MESSAGE]: Error sending message to http://{0}:{1} the host didn't respond ({2})", 
+                                  reginfo.ExternalHostName, reginfo.HttpPort, e.Message);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Get ulong region handle for region by it's Region UUID.
+        /// We use region handles over grid comms because there's all sorts of free and cool caching.
+        /// </summary>
+        /// <param name="regionID">UUID of region to get the region handle for</param>
+        /// <returns></returns>
+//        private ulong getLocalRegionHandleFromUUID(UUID regionID)
+//        {
+//            ulong returnhandle = 0;
+//
+//            lock (m_Scenes)
+//            {
+//                foreach (Scene sn in m_Scenes)
+//                {
+//                    if (sn.RegionInfo.RegionID == regionID)
+//                    {
+//                        returnhandle = sn.RegionInfo.RegionHandle;
+//                        break;
+//                    }
+//                }
+//            }
+//            return returnhandle;
+//        }
+
+        /// <summary>
+        /// Takes a GridInstantMessage and converts it into a Hashtable for XMLRPC
+        /// </summary>
+        /// <param name="msg">The GridInstantMessage object</param>
+        /// <returns>Hashtable containing the XMLRPC request</returns>
+        private Hashtable ConvertGridInstantMessageToXMLRPC(GridInstantMessage msg)
+        {
+            Hashtable gim = new Hashtable();
+            gim["from_agent_id"] = msg.fromAgentID.ToString();
+            // Kept for compatibility
+            gim["from_agent_session"] = UUID.Zero.ToString();
+            gim["to_agent_id"] = msg.toAgentID.ToString();
+            gim["im_session_id"] = msg.imSessionID.ToString();
+            gim["timestamp"] = msg.timestamp.ToString();
+            gim["from_agent_name"] = msg.fromAgentName;
+            gim["message"] = msg.message;
+            byte[] dialogdata = new byte[1];dialogdata[0] = msg.dialog;
+            gim["dialog"] = Convert.ToBase64String(dialogdata,Base64FormattingOptions.None);
+
+            if (msg.fromGroup)
+                gim["from_group"] = "TRUE";
+            else
+                gim["from_group"] = "FALSE";
+            byte[] offlinedata = new byte[1]; offlinedata[0] = msg.offline;
+            gim["offline"] = Convert.ToBase64String(offlinedata, Base64FormattingOptions.None);
+            gim["parent_estate_id"] = msg.ParentEstateID.ToString();
+            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["binary_bucket"] = Convert.ToBase64String(msg.binaryBucket,Base64FormattingOptions.None);
+            return gim;
+        }
+
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs
new file mode 100644
index 0000000..49fd70a
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs
@@ -0,0 +1,426 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Net;
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Framework.Client;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
+{
+    public class PresenceModule : IRegionModule, IPresenceModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private bool m_Enabled = false;
+        private bool m_Gridmode = false;
+
+        // some default scene for doing things that aren't connected to a specific scene. Avoids locking.
+        private Scene m_initialScene;
+
+        private List<Scene> m_Scenes = new List<Scene>();
+
+        // we currently are only interested in root-agents. If the root isn't here, we don't know the region the
+        // user is in, so we have to ask the messaging server anyway.
+        private Dictionary<UUID, Scene> m_RootAgents =
+                new Dictionary<UUID, Scene>();
+
+        public event PresenceChange OnPresenceChange;
+        public event BulkPresenceData OnBulkPresenceData;
+
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            lock (m_Scenes)
+            {
+                // This is a shared module; Initialise will be called for every region on this server.
+                // Only check config once for the first region.
+                if (m_Scenes.Count == 0)
+                {
+                    IConfig cnf = config.Configs["Messaging"];
+                    if (cnf != null && cnf.GetString(
+                            "PresenceModule", "PresenceModule") !=
+                            "PresenceModule")
+                        return;
+
+                    cnf = config.Configs["Startup"];
+                    if (cnf != null)
+                        m_Gridmode = cnf.GetBoolean("gridmode", false);
+
+                    m_Enabled = true;
+
+                    m_initialScene = scene;
+                }
+
+                if (m_Gridmode)
+                    NotifyMessageServerOfStartup(scene);
+
+                m_Scenes.Add(scene);
+            }
+
+            scene.RegisterModuleInterface<IPresenceModule>(this);
+
+            scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnSetRootAgentScene += OnSetRootAgentScene;
+            scene.EventManager.OnMakeChildAgent += OnMakeChildAgent;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+            if (!m_Gridmode || !m_Enabled)
+                return;
+
+            if (OnPresenceChange != null)
+            {
+                lock (m_RootAgents)
+                {
+                    // on shutdown, users are kicked, too
+                    foreach (KeyValuePair<UUID, Scene> pair in m_RootAgents)
+                    {
+                        OnPresenceChange(new PresenceInfo(pair.Key, UUID.Zero));
+                    }
+                }
+            }
+
+            lock (m_Scenes)
+            {
+                foreach (Scene scene in m_Scenes)
+                    NotifyMessageServerOfShutdown(scene);
+            }
+        }
+
+        public string Name
+        {
+            get { return "PresenceModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        public void RequestBulkPresenceData(UUID[] users)
+        {
+            if (OnBulkPresenceData != null)
+            {
+                PresenceInfo[] result = new PresenceInfo[users.Length];
+                if (m_Gridmode)
+                {
+                    // first check the local information
+                    List<UUID> uuids = new List<UUID>(); // the uuids to check remotely
+                    List<int> indices = new List<int>(); // just for performance.
+                    lock (m_RootAgents)
+                    {
+                        for (int i = 0; i < uuids.Count; ++i)
+                        {
+                            Scene scene;
+                            if (m_RootAgents.TryGetValue(users[i], out scene)) 
+                            {
+                                result[i] = new PresenceInfo(users[i], scene.RegionInfo.RegionID);
+                            }
+                            else
+                            {
+                                uuids.Add(users[i]);
+                                indices.Add(i);
+                            }
+                        }
+                    }
+
+                    // now we have filtered out all the local root agents. The rest we have to request info about
+                    Dictionary<UUID, FriendRegionInfo> infos = m_initialScene.GetFriendRegionInfos(uuids);
+                    for (int i = 0; i < uuids.Count; ++i)
+                    {
+                        FriendRegionInfo info;
+                        if (infos.TryGetValue(uuids[i], out info) && info.isOnline)
+                        {
+                            UUID regionID = info.regionID;
+                            if (regionID == UUID.Zero)
+                            {
+                                // TODO this is the old messaging-server protocol; only the regionHandle is available.
+                                // Fetch region-info to get the id
+                                RegionInfo regionInfo = m_initialScene.RequestNeighbouringRegionInfo(info.regionHandle);
+                                regionID = regionInfo.RegionID;
+                            }
+                            result[indices[i]] = new PresenceInfo(uuids[i], regionID);
+                        }
+                        else result[indices[i]] = new PresenceInfo(uuids[i], UUID.Zero);
+                    }
+                }
+                else
+                {
+                    // in standalone mode, we have all the info locally available.
+                    lock (m_RootAgents)
+                    {
+                        for (int i = 0; i < users.Length; ++i)
+                        {
+                            Scene scene;
+                            if (m_RootAgents.TryGetValue(users[i], out scene))
+                            {
+                                result[i] = new PresenceInfo(users[i], scene.RegionInfo.RegionID);
+                            }
+                            else
+                            {
+                                result[i] = new PresenceInfo(users[i], UUID.Zero);
+                            }
+                        }
+                    }
+                }
+
+                // tell everyone
+                OnBulkPresenceData(result);
+            }
+        }
+
+        // new client doesn't mean necessarily that user logged in, it just means it entered one of the
+        // the regions on this server
+        public void OnNewClient(IClientAPI client)
+        {
+            client.OnConnectionClosed += OnConnectionClosed;
+            client.OnLogout += OnLogout;
+
+            // KLUDGE: See handler for details.
+            client.OnEconomyDataRequest += OnEconomyDataRequest;
+        }
+
+        // connection closed just means *one* client connection has been closed. It doesn't mean that the
+        // user has logged off; it might have just TPed away.
+        public void OnConnectionClosed(IClientAPI client)
+        {
+            // TODO: Have to think what we have to do here...
+            // Should we just remove the root from the list (if scene matches)?
+            if (!(client.Scene is Scene))
+                return;
+            Scene scene = (Scene)client.Scene;
+
+            lock (m_RootAgents)
+            {
+                Scene rootScene;
+                if (!(m_RootAgents.TryGetValue(client.AgentId, out rootScene)) || scene != rootScene)
+                    return;
+
+                m_RootAgents.Remove(client.AgentId);
+            }
+
+            // Should it have logged off, we'll do the logout part in OnLogout, even if no root is stored
+            // anymore. It logged off, after all...
+        }
+
+        // Triggered when the user logs off.
+        public void OnLogout(IClientAPI client)
+        {
+            if (!(client.Scene is Scene))
+                return;
+            Scene scene = (Scene)client.Scene;
+
+            // On logout, we really remove the client from rootAgents, even if the scene doesn't match
+            lock (m_RootAgents)
+            {
+                if (m_RootAgents.ContainsKey(client.AgentId)) m_RootAgents.Remove(client.AgentId);
+            }
+
+            // now inform the messaging server and anyone who is interested
+            NotifyMessageServerOfAgentLeaving(client.AgentId, scene.RegionInfo.RegionID, scene.RegionInfo.RegionHandle);
+            if (OnPresenceChange != null) OnPresenceChange(new PresenceInfo(client.AgentId, UUID.Zero));
+        }
+
+        public void OnSetRootAgentScene(UUID agentID, Scene scene)
+        {
+            // OnSetRootAgentScene can be called from several threads at once (with different agentID).
+            // Concurrent access to m_RootAgents is prone to failure on multi-core/-processor systems without
+            // correct locking).
+            lock (m_RootAgents)
+            {
+                Scene rootScene;
+                if (m_RootAgents.TryGetValue(agentID, out rootScene) && scene == rootScene)
+                {
+                    return;
+                }
+                m_RootAgents[agentID] = scene;
+            }
+            // inform messaging server that agent changed the region
+            NotifyMessageServerOfAgentLocation(agentID, scene.RegionInfo.RegionID, scene.RegionInfo.RegionHandle);
+        }
+
+        private void OnEconomyDataRequest(UUID agentID)
+        {
+            // KLUDGE: This is the only way I found to get a message (only) after login was completed and the
+            // client is connected enough to receive UDP packets.
+            // This packet seems to be sent only once, just after connection was established to the first
+            // region after login.
+            // We use it here to trigger a presence update; the old update-on-login was never be heard by
+            // the freshly logged in viewer, as it wasn't connected to the region at that time.
+            // TODO: Feel free to replace this by a better solution if you find one.
+
+            // get the agent. This should work every time, as we just got a packet from it
+            ScenePresence agent = null;
+            lock (m_Scenes)
+            {
+                foreach (Scene scene in m_Scenes)
+                {
+                    agent = scene.GetScenePresence(agentID);
+                    if (agent != null) break;
+                }
+            }
+
+            // just to be paranoid...
+            if (agent == null)
+            {
+                m_log.ErrorFormat("[PRESENCE]: Got a packet from agent {0} who can't be found anymore!?", agentID);
+                return;
+            }
+
+            // we are a bit premature here, but the next packet will switch this child agent to root.
+            if (OnPresenceChange != null) OnPresenceChange(new PresenceInfo(agentID, agent.Scene.RegionInfo.RegionID));
+        }
+
+        public void OnMakeChildAgent(ScenePresence agent)
+        {
+            // OnMakeChildAgent can be called from several threads at once (with different agent).
+            // Concurrent access to m_RootAgents is prone to failure on multi-core/-processor systems without
+            // correct locking).
+            lock (m_RootAgents)
+            {
+                Scene rootScene;
+                if (m_RootAgents.TryGetValue(agent.UUID, out rootScene) && agent.Scene == rootScene)
+                {
+                    m_RootAgents.Remove(agent.UUID);
+                }
+            }
+            // don't notify the messaging-server; either this agent just had been downgraded and another one will be upgraded
+            // to root momentarily (which will notify the messaging-server), or possibly it will be closed in a moment,
+            // which will update the messaging-server, too.
+        }
+
+        private void NotifyMessageServerOfStartup(Scene scene)
+        {
+            Hashtable xmlrpcdata = new Hashtable();
+            xmlrpcdata["RegionUUID"] = scene.RegionInfo.RegionID.ToString();
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(xmlrpcdata);
+            try
+            {
+                XmlRpcRequest UpRequest = new XmlRpcRequest("region_startup", SendParams);
+                XmlRpcResponse resp = UpRequest.Send(scene.CommsManager.NetworkServersInfo.MessagingURL, 5000);
+
+                Hashtable responseData = (Hashtable)resp.Value;
+                if (responseData == null || (!responseData.ContainsKey("success")) || (string)responseData["success"] != "TRUE")
+                {
+                    m_log.ErrorFormat("[PRESENCE]: Failed to notify message server of region startup for region {0}", scene.RegionInfo.RegionName);
+                }
+            }
+            catch (System.Net.WebException)
+            {
+                m_log.ErrorFormat("[PRESENCE]: Failed to notify message server of region startup for region {0}", scene.RegionInfo.RegionName);
+            }
+        }
+
+        private void NotifyMessageServerOfShutdown(Scene scene)
+        {
+            Hashtable xmlrpcdata = new Hashtable();
+            xmlrpcdata["RegionUUID"] = scene.RegionInfo.RegionID.ToString();
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(xmlrpcdata);
+            try
+            {
+                XmlRpcRequest DownRequest = new XmlRpcRequest("region_shutdown", SendParams);
+                XmlRpcResponse resp = DownRequest.Send(scene.CommsManager.NetworkServersInfo.MessagingURL, 5000);
+
+                Hashtable responseData = (Hashtable)resp.Value;
+                if ((!responseData.ContainsKey("success")) || (string)responseData["success"] != "TRUE")
+                {
+                    m_log.ErrorFormat("[PRESENCE]: Failed to notify message server of region shutdown for region {0}", scene.RegionInfo.RegionName);
+                }
+            }
+            catch (System.Net.WebException)
+            {
+                m_log.ErrorFormat("[PRESENCE]: Failed to notify message server of region shutdown for region {0}", scene.RegionInfo.RegionName);
+            }
+        }
+
+        private void NotifyMessageServerOfAgentLocation(UUID agentID, UUID region, ulong regionHandle)
+        {
+            Hashtable xmlrpcdata = new Hashtable();
+            xmlrpcdata["AgentID"] = agentID.ToString();
+            xmlrpcdata["RegionUUID"] = region.ToString();
+            xmlrpcdata["RegionHandle"] = regionHandle.ToString();
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(xmlrpcdata);
+            try
+            {
+                XmlRpcRequest LocationRequest = new XmlRpcRequest("agent_location", SendParams);
+                XmlRpcResponse resp = LocationRequest.Send(m_Scenes[0].CommsManager.NetworkServersInfo.MessagingURL, 5000);
+
+                Hashtable responseData = (Hashtable)resp.Value;
+                if ((!responseData.ContainsKey("success")) || (string)responseData["success"] != "TRUE")
+                {
+                    m_log.ErrorFormat("[PRESENCE]: Failed to notify message server of agent location for {0}", agentID.ToString());
+                }
+            }
+            catch (System.Net.WebException)
+            {
+                m_log.ErrorFormat("[PRESENCE]: Failed to notify message server of agent location for {0}", agentID.ToString());
+            }
+        }
+
+        private void NotifyMessageServerOfAgentLeaving(UUID agentID, UUID region, ulong regionHandle)
+        {
+            Hashtable xmlrpcdata = new Hashtable();
+            xmlrpcdata["AgentID"] = agentID.ToString();
+            xmlrpcdata["RegionUUID"] = region.ToString();
+            xmlrpcdata["RegionHandle"] = regionHandle.ToString();
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(xmlrpcdata);
+            try
+            {
+                XmlRpcRequest LeavingRequest = new XmlRpcRequest("agent_leaving", SendParams);
+                XmlRpcResponse resp = LeavingRequest.Send(m_Scenes[0].CommsManager.NetworkServersInfo.MessagingURL, 5000);
+
+                Hashtable responseData = (Hashtable)resp.Value;
+                if ((!responseData.ContainsKey("success")) || (string)responseData["success"] != "TRUE")
+                {
+                    m_log.ErrorFormat("[PRESENCE]: Failed to notify message server of agent leaving for {0}", agentID.ToString());
+                }
+            }
+            catch (System.Net.WebException)
+            {
+                m_log.ErrorFormat("[PRESENCE]: Failed to notify message server of agent leaving for {0}", agentID.ToString());
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
new file mode 100644
index 0000000..49006a2
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs
@@ -0,0 +1,279 @@
+/*
+ * 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 OpenSim 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.IO.Compression;
+using System.Reflection;
+using System.Xml;
+using OpenMetaverse;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.CoreModules.World.Archiver;
+using OpenSim.Region.CoreModules.World.Serialiser;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.Communications.Cache;
+using log4net;
+
+
+namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
+{
+    public class InventoryArchiveReadRequest
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected Scene scene;
+        protected TarArchiveReader archive;
+        private static System.Text.ASCIIEncoding m_asciiEncoding = new System.Text.ASCIIEncoding();
+
+        CommunicationsManager commsManager;
+
+        public InventoryArchiveReadRequest(Scene currentScene, CommunicationsManager commsManager)
+        {
+            //List<string> serialisedObjects = new List<string>();
+            scene = currentScene;
+            this.commsManager = commsManager;
+        }
+
+        protected InventoryItemBase loadInvItem(string path, string contents)
+        {
+            InventoryItemBase item = new InventoryItemBase();
+            StringReader sr = new StringReader(contents);
+            XmlTextReader reader = new XmlTextReader(sr);
+
+            if (contents.Equals("")) return null;
+
+            reader.ReadStartElement("InventoryObject");
+            reader.ReadStartElement("Name");
+            item.Name = reader.ReadString();
+            reader.ReadEndElement();
+            reader.ReadStartElement("ID");
+            item.ID = UUID.Parse(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("InvType");
+            item.InvType = System.Convert.ToInt32(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("CreatorUUID");
+            item.Creator = UUID.Parse(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("CreationDate");
+            item.CreationDate = System.Convert.ToInt32(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("Owner");
+            item.Owner = UUID.Parse(reader.ReadString());
+            reader.ReadEndElement();
+            //No description would kill it
+            if (reader.IsEmptyElement)
+            {
+                reader.ReadStartElement("Description");
+            }
+            else
+            {
+                reader.ReadStartElement("Description");
+                item.Description = reader.ReadString();
+                reader.ReadEndElement();
+            }
+            reader.ReadStartElement("AssetType");
+            item.AssetType = System.Convert.ToInt32(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("AssetID");
+            item.AssetID = UUID.Parse(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("SaleType");
+            item.SaleType = System.Convert.ToByte(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("SalePrice");
+            item.SalePrice = System.Convert.ToInt32(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("BasePermissions");
+            item.BasePermissions = System.Convert.ToUInt32(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("CurrentPermissions");
+            item.CurrentPermissions = System.Convert.ToUInt32(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("EveryOnePermssions");
+            item.EveryOnePermissions = System.Convert.ToUInt32(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("NextPermissions");
+            item.NextPermissions = System.Convert.ToUInt32(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("Flags");
+            item.Flags = System.Convert.ToUInt32(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("GroupID");
+            item.GroupID = UUID.Parse(reader.ReadString());
+            reader.ReadEndElement();
+            reader.ReadStartElement("GroupOwned");
+            item.GroupOwned = System.Convert.ToBoolean(reader.ReadString());
+            reader.ReadEndElement();
+            //reader.ReadStartElement("ParentFolderID");
+            //item.Folder = UUID.Parse(reader.ReadString());
+            //reader.ReadEndElement();
+            //reader.ReadEndElement();
+
+            return item;
+        }
+
+        public void execute(string firstName, string lastName, string invPath, string loadPath)
+        {
+            string filePath = "ERROR";
+            int successfulAssetRestores = 0;
+            int failedAssetRestores = 0;
+            int successfulItemRestores = 0;
+
+            UserProfileData userProfile = commsManager.UserService.GetUserProfile(firstName, lastName);
+            if (null == userProfile)
+            {
+                m_log.ErrorFormat("[CONSOLE]: Failed to find user {0} {1}", firstName, lastName);
+                return;
+            }
+
+            CachedUserInfo userInfo = commsManager.UserProfileCacheService.GetUserDetails(userProfile.ID);
+            if (null == userInfo)
+            {
+                m_log.ErrorFormat(
+                    "[CONSOLE]: Failed to find user info for {0} {1} {2}",
+                    firstName, lastName, userProfile.ID);
+
+                return;
+            }
+
+            if (!userInfo.HasReceivedInventory)
+            {
+                m_log.ErrorFormat(
+                    "[CONSOLE]: Have not yet received inventory info for user {0} {1} {2}",
+                    firstName, lastName, userProfile.ID);
+
+                return;
+            }
+
+            InventoryFolderImpl inventoryFolder = userInfo.RootFolder.FindFolderByPath(invPath);
+
+            if (null == inventoryFolder)
+            {
+                // TODO: Later on, automatically create this folder if it does not exist
+                m_log.ErrorFormat("[ARCHIVER]: Inventory path {0} does not exist", invPath);
+
+                return;
+            }
+
+            archive
+                = new TarArchiveReader(new GZipStream(
+                    new FileStream(loadPath, FileMode.Open), CompressionMode.Decompress));
+
+            byte[] data;
+            TarArchiveReader.TarEntryType entryType;
+            while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
+            {
+                if (entryType == TarArchiveReader.TarEntryType.TYPE_DIRECTORY) {
+                    m_log.WarnFormat("[ARCHIVER]: Ignoring directory entry {0}", filePath);
+                } else if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
+                {
+                    if (LoadAsset(filePath, data))
+                        successfulAssetRestores++;
+                    else
+                        failedAssetRestores++;
+                }
+                else
+                {
+                    InventoryItemBase item = loadInvItem(filePath, m_asciiEncoding.GetString(data));
+
+                    if (item != null)
+                    {
+                        item.Creator = userProfile.ID;
+                        item.Owner = userProfile.ID;
+
+                        // Reset folder ID to the one in which we want to load it
+                        // TODO: Properly restore entire folder structure.  At the moment all items are dumped in this
+                        // single folder no matter where in the saved folder structure they are.
+                        item.Folder = inventoryFolder.ID;
+
+                        userInfo.AddItem(item);
+                        successfulItemRestores++;
+                    }
+                }
+            }
+
+            archive.Close();
+
+            m_log.DebugFormat("[ARCHIVER]: Restored {0} assets", successfulAssetRestores);
+            m_log.InfoFormat("[ARCHIVER]: Restored {0} items", successfulItemRestores);
+        }
+
+        /// <summary>
+        /// Load an asset
+        /// </summary>
+        /// <param name="assetFilename"></param>
+        /// <param name="data"></param>
+        /// <returns>true if asset was successfully loaded, false otherwise</returns>
+        private bool LoadAsset(string assetPath, byte[] data)
+        {
+            //IRegionSerialiser serialiser = scene.RequestModuleInterface<IRegionSerialiser>();
+            // Right now we're nastily obtaining the UUID from the filename
+            string filename = assetPath.Remove(0, ArchiveConstants.ASSETS_PATH.Length);
+            int i = filename.LastIndexOf(ArchiveConstants.ASSET_EXTENSION_SEPARATOR);
+
+            if (i == -1)
+            {
+                m_log.ErrorFormat(
+                   "[ARCHIVER]: Could not find extension information in asset path {0} since it's missing the separator {1}.  Skipping",
+                    assetPath, ArchiveConstants.ASSET_EXTENSION_SEPARATOR);
+
+                return false;
+            }
+
+            string extension = filename.Substring(i);
+            string uuid = filename.Remove(filename.Length - extension.Length);
+
+            if (ArchiveConstants.EXTENSION_TO_ASSET_TYPE.ContainsKey(extension))
+            {
+                sbyte assetType = ArchiveConstants.EXTENSION_TO_ASSET_TYPE[extension];
+
+                m_log.DebugFormat("[ARCHIVER]: Importing asset {0}, type {1}", uuid, assetType);
+
+                AssetBase asset = new AssetBase(new UUID(uuid), "RandomName");
+
+                asset.Metadata.Type = assetType;
+                asset.Data = data;
+
+                scene.AssetCache.AddAsset(asset);
+
+
+                return true;
+            }
+            else
+            {
+                m_log.ErrorFormat(
+                   "[ARCHIVER]: Tried to dearchive data with path {0} with an unknown type extension {1}",
+                    assetPath, extension);
+
+                return false;
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs
new file mode 100644
index 0000000..f548296
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveWriteRequest.cs
@@ -0,0 +1,247 @@
+/*
+ * 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 OpenSim 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.IO.Compression;
+using System.Reflection;
+using System.Xml;
+using OpenMetaverse;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.CoreModules.World.Archiver;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.Communications.Cache;
+using log4net;
+
+
+namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver
+{        
+    public class InventoryArchiveWriteRequest
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        protected Scene scene;
+        protected TarArchiveWriter archive;
+        protected CommunicationsManager commsManager;
+        Dictionary<UUID, int> assetUuids;
+        
+        /// <value>
+        /// The path to which the inventory archive will be saved.
+        /// </value>
+        private string m_savePath;
+
+        public InventoryArchiveWriteRequest(Scene currentScene, CommunicationsManager commsManager)
+        {
+            scene = currentScene;
+            archive = new TarArchiveWriter();
+            this.commsManager = commsManager;
+            assetUuids = new Dictionary<UUID, int>();
+        }
+
+        protected void ReceivedAllAssets(IDictionary<UUID, AssetBase> assetsFound, ICollection<UUID> assetsNotFoundUuids)
+        {
+            AssetsArchiver assetsArchiver = new AssetsArchiver(assetsFound);
+            assetsArchiver.Archive(archive);
+            archive.WriteTar(new GZipStream(new FileStream(m_savePath, FileMode.Create), CompressionMode.Compress));
+        }
+
+        protected void saveInvItem(InventoryItemBase inventoryItem, string path)
+        {
+            string filename
+                    = string.Format("{0}{1}_{2}.xml",
+                        path, inventoryItem.Name, inventoryItem.ID);
+            StringWriter sw = new StringWriter();
+            XmlTextWriter writer = new XmlTextWriter(sw);
+            writer.WriteStartElement("InventoryObject");
+            writer.WriteStartElement("Name");
+            writer.WriteString(inventoryItem.Name);
+            writer.WriteEndElement();
+            writer.WriteStartElement("ID");
+            writer.WriteString(inventoryItem.ID.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("InvType");
+            writer.WriteString(inventoryItem.InvType.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("CreatorUUID");
+            writer.WriteString(inventoryItem.Creator.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("CreationDate");
+            writer.WriteString(inventoryItem.CreationDate.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("Owner");
+            writer.WriteString(inventoryItem.Owner.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("Description");
+            if (inventoryItem.Description.Length > 0)
+                writer.WriteString(inventoryItem.Description);
+            else writer.WriteString("No Description");
+            writer.WriteEndElement();
+            writer.WriteStartElement("AssetType");
+            writer.WriteString(inventoryItem.AssetType.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("AssetID");
+            writer.WriteString(inventoryItem.AssetID.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("SaleType");
+            writer.WriteString(inventoryItem.SaleType.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("SalePrice");
+            writer.WriteString(inventoryItem.SalePrice.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("BasePermissions");
+            writer.WriteString(inventoryItem.BasePermissions.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("CurrentPermissions");
+            writer.WriteString(inventoryItem.CurrentPermissions.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("EveryOnePermssions");
+            writer.WriteString(inventoryItem.EveryOnePermissions.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("NextPermissions");
+            writer.WriteString(inventoryItem.NextPermissions.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("Flags");
+            writer.WriteString(inventoryItem.Flags.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("GroupID");
+            writer.WriteString(inventoryItem.GroupID.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("GroupOwned");
+            writer.WriteString(inventoryItem.GroupOwned.ToString());
+            writer.WriteEndElement();
+            writer.WriteStartElement("ParentFolderID");
+            writer.WriteString(inventoryItem.Folder.ToString());
+            writer.WriteEndElement();
+            writer.WriteEndElement();
+
+            archive.AddFile(filename, sw.ToString());
+
+            assetUuids[inventoryItem.AssetID] = 1;
+        }
+
+        protected void saveInvDir(InventoryFolderImpl inventoryFolder, string path)
+        {
+            List<InventoryFolderImpl> inventories = inventoryFolder.RequestListOfFolderImpls();
+            List<InventoryItemBase> items = inventoryFolder.RequestListOfItems();
+            string newPath = path + inventoryFolder.Name + InventoryFolderImpl.PATH_DELIMITER;
+            archive.AddDir(newPath);
+            foreach (InventoryFolderImpl folder in inventories)
+            {
+                saveInvDir(folder, newPath);
+            }
+            foreach (InventoryItemBase item in items)
+            {
+                saveInvItem(item, newPath);
+            }
+        }
+
+        public void execute(string firstName, string lastName, string invPath, string savePath)
+        {
+            m_savePath = savePath;
+            
+            UserProfileData userProfile = commsManager.UserService.GetUserProfile(firstName, lastName);
+            if (null == userProfile)
+            {
+                m_log.ErrorFormat("[CONSOLE]: Failed to find user {0} {1}", firstName, lastName);
+                return;
+            }
+
+            CachedUserInfo userInfo = commsManager.UserProfileCacheService.GetUserDetails(userProfile.ID);
+            if (null == userInfo)
+            {
+                m_log.ErrorFormat("[CONSOLE]: Failed to find user info for {0} {1} {2}", firstName, lastName, userProfile.ID);
+                return;
+            }
+
+            InventoryFolderImpl inventoryFolder = null;
+            InventoryItemBase inventoryItem = null;
+
+            if (userInfo.HasReceivedInventory)
+            {
+                // Eliminate double slashes and any leading / on the path.  This might be better done within InventoryFolderImpl
+                // itself (possibly at a small loss in efficiency).
+                string[] components
+                    = invPath.Split(new string[] { InventoryFolderImpl.PATH_DELIMITER }, StringSplitOptions.RemoveEmptyEntries);
+                invPath = String.Empty;
+                foreach (string c in components)
+                {
+                    invPath += c + InventoryFolderImpl.PATH_DELIMITER;
+                }
+
+                // Annoyingly Split actually returns the original string if the input string consists only of delimiters
+                // Therefore if we still start with a / after the split, then we need the root folder
+                if (invPath.Length == 0)
+                {
+                    inventoryFolder = userInfo.RootFolder;
+                }
+                else
+                {
+                    invPath = invPath.Remove(invPath.LastIndexOf(InventoryFolderImpl.PATH_DELIMITER));
+                    inventoryFolder = userInfo.RootFolder.FindFolderByPath(invPath);
+                }
+
+                // The path may point to an item instead
+                if (inventoryFolder == null)
+                {
+                    inventoryItem = userInfo.RootFolder.FindItemByPath(invPath);
+                }
+            }
+            else
+            {
+                m_log.ErrorFormat("[CONSOLE]: Have not yet received inventory info for user {0} {1} {2}", firstName, lastName, userProfile.ID);
+                return;
+            }
+
+            if (null == inventoryFolder)
+            {
+                if (null == inventoryItem)
+                {
+                    m_log.ErrorFormat("[CONSOLE]: Could not find inventory entry at path {0}", invPath);
+                    return;
+                }
+                else
+                {
+                    m_log.InfoFormat("[CONSOLE]: Found item {0} {1} at {2}", inventoryItem.Name, inventoryItem.ID,
+                                     invPath);
+                    //get and export item info
+                    saveInvItem(inventoryItem, invPath);
+                }
+            }
+            else
+            {
+                m_log.InfoFormat("[CONSOLE]: Found folder {0} {1} at {2}", inventoryFolder.Name, inventoryFolder.ID,
+                                 invPath);
+                //recurse through all dirs getting dirs and files
+                saveInvDir(inventoryFolder, "");
+            }
+
+            new AssetsRequest(assetUuids.Keys, scene.AssetCache, ReceivedAllAssets).Execute();
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs
new file mode 100644
index 0000000..d2cf6c9
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs
@@ -0,0 +1,389 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Communications.Cache;
+
+namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
+{
+    public class InventoryTransferModule : IInventoryTransferModule, IRegionModule
+    {
+        private static readonly ILog m_log
+            = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        private List<Scene> m_Scenelist = new List<Scene>();
+        private Dictionary<UUID, Scene> m_AgentRegions =
+                new Dictionary<UUID, Scene>();
+
+        private IMessageTransferModule m_TransferModule = null;
+
+        #region IRegionModule Members
+
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            if (config.Configs["Messaging"] != null)
+            {
+                // Allow disabling this module in config
+                //
+                if (config.Configs["Messaging"].GetString(
+                        "InventoryTransferModule", "InventoryTransferModule") !=
+                        "InventoryTransferModule")
+                    return;
+            }
+
+            if (!m_Scenelist.Contains(scene))
+            {
+                if (m_Scenelist.Count == 0)
+                {
+                    m_TransferModule = scene.RequestModuleInterface<IMessageTransferModule>();
+                    if (m_TransferModule == null)
+                        m_log.Error("[INVENTORY TRANSFER] No Message transfer module found, transfers will be local only");
+                }
+
+                m_Scenelist.Add(scene);
+
+                scene.RegisterModuleInterface<IInventoryTransferModule>(this);
+
+                scene.EventManager.OnNewClient += OnNewClient;
+                scene.EventManager.OnClientClosed += ClientLoggedOut;
+            }
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "InventoryModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        #endregion
+
+        private void OnNewClient(IClientAPI client)
+        {
+            // Inventory giving is conducted via instant message
+            client.OnInstantMessage += OnInstantMessage;
+        }
+
+        private Scene FindClientScene(UUID agentId)
+        {
+            lock (m_Scenelist)
+            {
+                foreach (Scene scene in m_Scenelist)
+                {
+                    ScenePresence presence = scene.GetScenePresence(agentId);
+                    if (presence != null)
+                    {
+                        if (!presence.IsChildAgent)
+                            return scene;
+                    }
+                }
+            }
+            return null;
+        }
+
+        private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
+        {
+            Scene scene = FindClientScene(client.AgentId);
+
+            if (scene == null) // Something seriously wrong here.
+                return;
+
+            if (im.dialog == (byte) InstantMessageDialog.InventoryOffered)
+            {
+                //m_log.DebugFormat("Asset type {0}", ((AssetType)im.binaryBucket[0]));
+                
+                ScenePresence user = scene.GetScenePresence(new UUID(im.toAgentID));
+                UUID copyID;
+
+                // First byte is the asset type
+                AssetType assetType = (AssetType)im.binaryBucket[0];
+                
+                if (AssetType.Folder == assetType)
+                {
+                    UUID folderID = new UUID(im.binaryBucket, 1);
+                    
+                    m_log.DebugFormat("[AGENT INVENTORY]: Inserting original folder {0} "+
+                            "into agent {1}'s inventory",
+                            folderID, new UUID(im.toAgentID));
+                    
+                    InventoryFolderImpl folderCopy 
+                        = scene.GiveInventoryFolder(new UUID(im.toAgentID), client.AgentId, folderID, UUID.Zero);
+                    
+                    if (folderCopy == null)
+                    {
+                        client.SendAgentAlertMessage("Can't find folder to give. Nothing given.", false);
+                        return;
+                    }
+                                                           
+                    // The outgoing binary bucket should contain only the byte which signals an asset folder is
+                    // being copied and the following bytes for the copied folder's UUID
+                    copyID = folderCopy.ID;
+                    byte[] copyIDBytes = copyID.GetBytes();
+                    im.binaryBucket = new byte[1 + copyIDBytes.Length];
+                    im.binaryBucket[0] = (byte)AssetType.Folder;
+                    Array.Copy(copyIDBytes, 0, im.binaryBucket, 1, copyIDBytes.Length);  
+                    
+                    if (user != null && !user.IsChildAgent)
+                    {        
+                        user.ControllingClient.SendBulkUpdateInventory(folderCopy);
+                    }                    
+                }
+                else
+                {
+                    // First byte of the array is probably the item type
+                    // Next 16 bytes are the UUID
+
+                    UUID itemID = new UUID(im.binaryBucket, 1);
+
+                    m_log.DebugFormat("[AGENT INVENTORY]: Inserting item {0} "+
+                            "into agent {1}'s inventory",
+                            itemID, new UUID(im.toAgentID));
+
+                    InventoryItemBase itemCopy = scene.GiveInventoryItem(
+                            new UUID(im.toAgentID),
+                            client.AgentId, itemID);
+
+                    if (itemCopy == null)
+                    {
+                        client.SendAgentAlertMessage("Can't find item to give. Nothing given.", false);
+                        return;
+                    }
+                    
+                    copyID = itemCopy.ID;
+                    Array.Copy(copyID.GetBytes(), 0, im.binaryBucket, 1, 16);                                       
+                    
+                    if (user != null && !user.IsChildAgent)
+                    {        
+                        user.ControllingClient.SendBulkUpdateInventory(itemCopy);
+                    }
+                }
+
+                // Send the IM to the recipient. The item is already
+                // in their inventory, so it will not be lost if
+                // they are offline.
+                //
+                if (user != null && !user.IsChildAgent)
+                {
+                    // And notify. Transaction ID is the item ID. We get that
+                    // same ID back on the reply so we know what to act on
+                    //
+                    user.ControllingClient.SendInstantMessage(
+                            new UUID(im.fromAgentID), im.message,
+                            new UUID(im.toAgentID),
+                            im.fromAgentName, im.dialog, im.timestamp,
+                            copyID, false, im.binaryBucket);
+
+                    return;
+                }
+                else
+                {
+                    if (m_TransferModule != null)
+                        m_TransferModule.SendInstantMessage(im, delegate(bool success) {} );
+                }
+            }
+            else if (im.dialog == (byte) InstantMessageDialog.InventoryAccepted)
+            {
+                ScenePresence user = scene.GetScenePresence(new UUID(im.toAgentID));
+
+                if (user != null) // Local
+                {
+                    user.ControllingClient.SendInstantMessage(
+                            new UUID(im.fromAgentID), im.message,
+                            new UUID(im.toAgentID),
+                            im.fromAgentName, im.dialog, im.timestamp,
+                            UUID.Zero, false, im.binaryBucket);
+                }
+                else
+                {
+                    if (m_TransferModule != null)
+                        m_TransferModule.SendInstantMessage(im, delegate(bool success) {} );
+                }
+            }
+            else if (im.dialog == (byte) InstantMessageDialog.InventoryDeclined)
+            {                                           
+                // Here, the recipient is local and we can assume that the
+                // inventory is loaded. Courtesy of the above bulk update,
+                // It will have been pushed to the client, too
+                //
+                
+                CachedUserInfo userInfo =
+                        scene.CommsManager.UserProfileCacheService.
+                        GetUserDetails(client.AgentId);
+
+                if (userInfo != null)
+                {
+                    InventoryFolderImpl trashFolder =
+                        userInfo.FindFolderForType((int)AssetType.TrashFolder);
+                    
+                    UUID inventoryEntityID = new UUID(im.imSessionID); // The inventory item/folder, back from it's trip
+                        
+                    InventoryItemBase item = userInfo.RootFolder.FindItem(inventoryEntityID);
+                    InventoryFolderBase folder = null;
+                    
+                    if (item != null && trashFolder != null)
+                    {
+                        item.Folder = trashFolder.ID;
+
+                        userInfo.DeleteItem(inventoryEntityID);
+
+                        scene.AddInventoryItem(client, item);
+                    }
+                    else
+                    {
+                        folder = userInfo.RootFolder.FindFolder(inventoryEntityID);
+                        
+                        if (folder != null & trashFolder != null)
+                        {
+                            userInfo.MoveFolder(inventoryEntityID, trashFolder.ID);
+                        }
+                    }
+                    
+                    if ((null == item && null == folder) | null == trashFolder)
+                    {                        
+                        string reason = String.Empty;
+                        
+                        if (trashFolder == null)
+                            reason += " Trash folder not found.";
+                        if (item == null)
+                            reason += " Item not found.";
+                        if (folder == null)
+                            reason += " Folder not found.";
+                        
+                        client.SendAgentAlertMessage("Unable to delete "+
+                                "received inventory" + reason, false);
+                    }
+                }
+
+                ScenePresence user = scene.GetScenePresence(new UUID(im.toAgentID));
+
+                if (user != null) // Local
+                {
+                    user.ControllingClient.SendInstantMessage(
+                            new UUID(im.fromAgentID), im.message,
+                            new UUID(im.toAgentID),
+                            im.fromAgentName, im.dialog, im.timestamp,
+                            UUID.Zero, false, im.binaryBucket);
+                }
+                else
+                {
+                    if (m_TransferModule != null)
+                        m_TransferModule.SendInstantMessage(im, delegate(bool success) {} );
+                }
+            }
+        }
+
+        public void SetRootAgentScene(UUID agentID, Scene scene)
+        {
+            m_AgentRegions[agentID] = scene;
+        }
+
+        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.TryGetAvatar(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)
+        {
+            if (m_AgentRegions.ContainsKey(agentID))
+                m_AgentRegions.Remove(agentID);
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Lure/LureModule.cs b/OpenSim/Region/CoreModules/Avatar/Lure/LureModule.cs
new file mode 100644
index 0000000..ebf4f0a
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Lure/LureModule.cs
@@ -0,0 +1,176 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Net;
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Framework.Client;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.Lure
+{
+    public class LureModule : IRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private readonly List<Scene> m_scenes = new List<Scene>();
+
+        private IMessageTransferModule m_TransferModule = null;
+
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            if (config.Configs["Messaging"] != null)
+            {
+                if (config.Configs["Messaging"].GetString(
+                        "LureModule", "LureModule") !=
+                        "LureModule")
+                    return;
+            }
+
+            lock (m_scenes)
+            {
+                if (!m_scenes.Contains(scene))
+                {
+                    m_scenes.Add(scene);
+                    scene.EventManager.OnNewClient += OnNewClient;
+                    scene.EventManager.OnIncomingInstantMessage +=
+                            OnGridInstantMessage;
+                }
+            }
+        }
+
+        void OnNewClient(IClientAPI client)
+        {
+            client.OnInstantMessage += OnInstantMessage;
+            client.OnStartLure += OnStartLure;
+            client.OnTeleportLureRequest += OnTeleportLureRequest;
+        }
+
+        public void PostInitialise()
+        {
+            m_TransferModule =
+                m_scenes[0].RequestModuleInterface<IMessageTransferModule>();
+
+            if (m_TransferModule == null)
+                m_log.Error("[INSTANT MESSAGE]: No message transfer module, "+
+                "lures will not work!");
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "LureModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        public void OnInstantMessage(IClientAPI client, GridInstantMessage im)
+        {
+        }
+
+        public void OnStartLure(byte lureType, string message, UUID targetid, IClientAPI client)
+        {
+            if (!(client.Scene is Scene))
+                return;
+
+            Scene scene = (Scene)(client.Scene);
+            ScenePresence presence = scene.GetScenePresence(client.AgentId);
+
+            UUID dest = Util.BuildFakeParcelID(
+                    scene.RegionInfo.RegionHandle,
+                    (uint)presence.AbsolutePosition.X,
+                    (uint)presence.AbsolutePosition.Y,
+                    (uint)presence.AbsolutePosition.Z);
+
+            m_log.DebugFormat("TP invite with message {0}", message);
+
+            GridInstantMessage m = new GridInstantMessage(scene, client.AgentId,
+                    client.FirstName+" "+client.LastName, targetid,
+                    (byte)InstantMessageDialog.RequestTeleport, false,
+                    message, dest, false, presence.AbsolutePosition,
+                    new Byte[0]);
+                    
+            if (m_TransferModule != null)
+            {
+                m_TransferModule.SendInstantMessage(m,
+                    delegate(bool success) { });
+            }
+        }
+
+        public void OnTeleportLureRequest(UUID lureID, uint teleportFlags, IClientAPI client)
+        {
+            if (!(client.Scene is Scene))
+                return;
+
+            Scene scene = (Scene)(client.Scene);
+
+            ulong handle = 0;
+            uint x = 128;
+            uint y = 128;
+            uint z = 70;
+
+            Util.ParseFakeParcelID(lureID, out handle, out x, out y, out z);
+
+            Vector3 position = new Vector3();
+            position.X = (float)x;
+            position.Y = (float)y;
+            position.Z = (float)z;
+
+            scene.RequestTeleportLocation(client, handle, position,
+                    Vector3.Zero, teleportFlags);
+        }
+
+        private void OnGridInstantMessage(GridInstantMessage msg)
+        {
+            // Forward remote teleport requests
+            //
+            if (msg.dialog != 22)
+                return;
+
+            if (m_TransferModule != null)
+            {
+                m_TransferModule.SendInstantMessage(msg,
+                    delegate(bool success) { });
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/ObjectCaps/ObjectAdd.cs b/OpenSim/Region/CoreModules/Avatar/ObjectCaps/ObjectAdd.cs
new file mode 100644
index 0000000..193307d
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/ObjectCaps/ObjectAdd.cs
@@ -0,0 +1,368 @@
+/*
+ * 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 OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Caps = OpenSim.Framework.Communications.Capabilities.Caps;
+
+namespace OpenSim.Region.CoreModules.Avatar.ObjectCaps
+{
+    public class ObjectAdd : IRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private Scene m_scene;
+        #region IRegionModule Members
+
+        public void Initialise(Scene pScene, IConfigSource pSource)
+        {
+            m_scene = pScene;
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void PostInitialise()
+        {
+            
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capuuid = UUID.Random();
+            
+            m_log.InfoFormat("[OBJECTADD]: {0}", "/CAPS/OA/" + capuuid + "/");
+
+            caps.RegisterHandler("ObjectAdd",
+                                 new RestHTTPHandler("POST", "/CAPS/OA/" + capuuid + "/",
+                                                       delegate(Hashtable m_dhttpMethod)
+                                                       {
+                                                           return ProcessAdd(m_dhttpMethod, agentID, caps);
+                                                       }));
+        }
+
+        public Hashtable ProcessAdd(Hashtable request, UUID AgentId, Caps cap)
+        {
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 400; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = "Request wasn't what was expected";
+            ScenePresence avatar;
+            
+            if (!m_scene.TryGetAvatar(AgentId, out avatar))
+                return responsedata;
+
+
+            OSD r = OSDParser.DeserializeLLSDXml((string)request["requestbody"]);
+            //UUID session_id = UUID.Zero;
+            bool bypass_raycast = false;
+            uint everyone_mask = 0;
+            uint group_mask = 0;
+            uint next_owner_mask = 0;
+            uint flags = 0;
+            UUID group_id = UUID.Zero;
+            int hollow = 0;
+            int material = 0;
+            int p_code = 0;
+            int path_begin = 0;
+            int path_curve = 0;
+            int path_end = 0;
+            int path_radius_offset = 0;
+            int path_revolutions = 0;
+            int path_scale_x = 0;
+            int path_scale_y = 0;
+            int path_shear_x = 0;
+            int path_shear_y = 0;
+            int path_skew = 0;
+            int path_taper_x = 0;
+            int path_taper_y = 0;
+            int path_twist = 0;
+            int path_twist_begin = 0;
+            int profile_begin = 0;
+            int profile_curve = 0;
+            int profile_end = 0;
+            Vector3 ray_end = Vector3.Zero;
+            bool ray_end_is_intersection = false;
+            Vector3 ray_start = Vector3.Zero;
+            UUID ray_target_id = UUID.Zero;
+            Quaternion rotation = Quaternion.Identity;
+            Vector3 scale = Vector3.Zero;
+            int state = 0;
+
+            if (r.Type != OSDType.Map) // not a proper req
+                return responsedata;
+            
+            OSDMap rm = (OSDMap)r;
+
+            if (rm.ContainsKey("ObjectData")) //v2
+            {
+                if (rm["ObjectData"].Type != OSDType.Map)
+                {
+                    responsedata["str_response_string"] = "Has ObjectData key, but data not in expected format";
+                    return responsedata;
+                }
+
+                OSDMap ObjMap = (OSDMap) rm["ObjectData"];
+
+                bypass_raycast = ObjMap["BypassRaycast"].AsBoolean();
+                everyone_mask = readuintval(ObjMap["EveryoneMask"]);
+                flags = readuintval(ObjMap["Flags"]);
+                group_mask = readuintval(ObjMap["GroupMask"]);
+                material = ObjMap["Material"].AsInteger();
+                next_owner_mask = readuintval(ObjMap["NextOwnerMask"]);
+                p_code = ObjMap["PCode"].AsInteger();
+
+                if (ObjMap.ContainsKey("Path"))
+                {
+                    if (ObjMap["Path"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has Path key, but data not in expected format";
+                        return responsedata;
+                    }
+
+                    OSDMap PathMap = (OSDMap)ObjMap["Path"];
+                    path_begin = PathMap["Begin"].AsInteger();
+                    path_curve = PathMap["Curve"].AsInteger();
+                    path_end = PathMap["End"].AsInteger();
+                    path_radius_offset = PathMap["RadiusOffset"].AsInteger();
+                    path_revolutions = PathMap["Revolutions"].AsInteger();
+                    path_scale_x = PathMap["ScaleX"].AsInteger();
+                    path_scale_y = PathMap["ScaleY"].AsInteger();
+                    path_shear_x = PathMap["ShearX"].AsInteger();
+                    path_shear_y = PathMap["ShearY"].AsInteger();
+                    path_skew = PathMap["Skew"].AsInteger();
+                    path_taper_x = PathMap["TaperX"].AsInteger();
+                    path_taper_y = PathMap["TaperY"].AsInteger();
+                    path_twist = PathMap["Twist"].AsInteger();
+                    path_twist_begin = PathMap["TwistBegin"].AsInteger();
+
+                }
+
+                if (ObjMap.ContainsKey("Profile"))
+                {
+                    if (ObjMap["Profile"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has Profile key, but data not in expected format";
+                        return responsedata;
+                    }
+                        
+                    OSDMap ProfileMap = (OSDMap)ObjMap["Profile"];
+
+                    profile_begin = ProfileMap["Begin"].AsInteger();
+                    profile_curve = ProfileMap["Curve"].AsInteger();
+                    profile_end = ProfileMap["End"].AsInteger();
+                    hollow = ProfileMap["Hollow"].AsInteger();
+                }
+                ray_end_is_intersection = ObjMap["RayEndIsIntersection"].AsBoolean();
+                
+                ray_target_id = ObjMap["RayTargetId"].AsUUID();
+                state = ObjMap["State"].AsInteger();
+                try
+                {
+                    ray_end = ((OSDArray) ObjMap["RayEnd"]).AsVector3();
+                    ray_start = ((OSDArray) ObjMap["RayStart"]).AsVector3();
+                    scale = ((OSDArray) ObjMap["Scale"]).AsVector3();
+                    rotation = ((OSDArray)ObjMap["Rotation"]).AsQuaternion();
+                }
+                catch (Exception)
+                {
+                    responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format";
+                    return responsedata;
+                }
+
+                if (rm.ContainsKey("AgentData"))
+                {
+                    if (rm["AgentData"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has AgentData key, but data not in expected format";
+                        return responsedata;
+                    }
+
+                    OSDMap AgentDataMap = (OSDMap) rm["AgentData"];
+
+                    //session_id = AgentDataMap["SessionId"].AsUUID();
+                    group_id = AgentDataMap["GroupId"].AsUUID();
+                }
+
+            }
+            else
+            { //v1
+                bypass_raycast = rm["bypass_raycast"].AsBoolean();
+
+                everyone_mask = readuintval(rm["everyone_mask"]);
+                flags = readuintval(rm["flags"]);
+                group_id = rm["group_id"].AsUUID();
+                group_mask = readuintval(rm["group_mask"]);
+                hollow = rm["hollow"].AsInteger();
+                material = rm["material"].AsInteger();
+                next_owner_mask = readuintval(rm["next_owner_mask"]);
+                hollow = rm["hollow"].AsInteger();
+                p_code = rm["p_code"].AsInteger();
+                path_begin = rm["path_begin"].AsInteger();
+                path_curve = rm["path_curve"].AsInteger();
+                path_end = rm["path_end"].AsInteger();
+                path_radius_offset = rm["path_radius_offset"].AsInteger();
+                path_revolutions = rm["path_revolutions"].AsInteger();
+                path_scale_x = rm["path_scale_x"].AsInteger();
+                path_scale_y = rm["path_scale_y"].AsInteger();
+                path_shear_x = rm["path_shear_x"].AsInteger();
+                path_shear_y = rm["path_shear_y"].AsInteger();
+                path_skew = rm["path_skew"].AsInteger();
+                path_taper_x = rm["path_taper_x"].AsInteger();
+                path_taper_y = rm["path_taper_y"].AsInteger();
+                path_twist = rm["path_twist"].AsInteger();
+                path_twist_begin = rm["path_twist_begin"].AsInteger();
+                profile_begin = rm["profile_begin"].AsInteger();
+                profile_curve = rm["profile_curve"].AsInteger();
+                profile_end = rm["profile_end"].AsInteger();
+                
+                ray_end_is_intersection = rm["ray_end_is_intersection"].AsBoolean();
+                
+                ray_target_id = rm["ray_target_id"].AsUUID();
+                
+                
+                //session_id = rm["session_id"].AsUUID();
+                state = rm["state"].AsInteger();
+                try 
+                {
+                    ray_end = ((OSDArray)rm["ray_end"]).AsVector3();
+                    ray_start = ((OSDArray)rm["ray_start"]).AsVector3();
+                    rotation = ((OSDArray)rm["rotation"]).AsQuaternion();
+                    scale = ((OSDArray)rm["scale"]).AsVector3();
+                } 
+                catch (Exception)
+                {
+                    responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format";
+                    return responsedata;
+                }
+            }
+
+           
+
+            Vector3 pos = m_scene.GetNewRezLocation(ray_start, ray_end, ray_target_id, rotation, (bypass_raycast) ? (byte)1 : (byte)0,  (ray_end_is_intersection) ? (byte)1 : (byte)0, true, scale, false);
+
+            PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+
+            pbs.PathBegin = (ushort)path_begin;
+            pbs.PathCurve = (byte)path_curve;
+            pbs.PathEnd = (ushort)path_end;
+            pbs.PathRadiusOffset = (sbyte)path_radius_offset;
+            pbs.PathRevolutions = (byte)path_revolutions;
+            pbs.PathScaleX = (byte)path_scale_x;
+            pbs.PathScaleY = (byte)path_scale_y;
+            pbs.PathShearX = (byte) path_shear_x;
+            pbs.PathShearY = (byte)path_shear_y;
+            pbs.PathSkew = (sbyte)path_skew;
+            pbs.PathTaperX = (sbyte)path_taper_x;
+            pbs.PathTaperY = (sbyte)path_taper_y;
+            pbs.PathTwist = (sbyte)path_twist;
+            pbs.PathTwistBegin = (sbyte)path_twist_begin;
+            pbs.HollowShape = (HollowShape) hollow;
+            pbs.PCode = (byte)p_code;
+            pbs.ProfileBegin = (ushort) profile_begin;
+            pbs.ProfileCurve = (byte) profile_curve;
+            pbs.ProfileEnd = (ushort)profile_end;
+            pbs.Scale = scale;
+            pbs.State = (byte)state;
+
+            SceneObjectGroup obj = null; ;
+
+            if (m_scene.Permissions.CanRezObject(1, avatar.UUID, pos))
+            {
+                // rez ON the ground, not IN the ground
+                pos.Z += 0.25F;
+
+                obj = m_scene.AddNewPrim(avatar.UUID, group_id, pos, rotation, pbs);
+            }
+
+
+            if (obj == null)
+                return responsedata;
+
+            SceneObjectPart rootpart = obj.RootPart;
+            rootpart.Shape = pbs;
+            rootpart.Flags |= (PrimFlags)flags;
+            rootpart.EveryoneMask = everyone_mask;
+            rootpart.GroupID = group_id;
+            rootpart.GroupMask = group_mask;
+            rootpart.NextOwnerMask = next_owner_mask;
+            rootpart.Material = (byte)material;
+            
+            
+            
+            m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
+            
+            responsedata["int_response_code"] = 200; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = String.Format("<llsd><map><key>local_id</key>{0}</map></llsd>",ConvertUintToBytes(obj.LocalId));
+
+            return responsedata;
+        }
+
+        private uint readuintval(OSD obj)
+        {
+            byte[] tmp = obj.AsBinary();
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(tmp);
+            return Utils.BytesToUInt(tmp);
+
+        }
+        private string ConvertUintToBytes(uint val)
+        {
+            byte[] resultbytes = Utils.UIntToBytes(val);
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(resultbytes);
+            return String.Format("<binary encoding=\"base64\">{0}</binary>",Convert.ToBase64String(resultbytes));
+        }
+
+        public void Close()
+        {
+            
+        }
+
+        public string Name
+        {
+            get { return "ObjectAddModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Profiles/AvatarProfilesModule.cs b/OpenSim/Region/CoreModules/Avatar/Profiles/AvatarProfilesModule.cs
new file mode 100644
index 0000000..6ea5b56
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Avatar/Profiles/AvatarProfilesModule.cs
@@ -0,0 +1,145 @@
+/*
+ * 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 OpenSim 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.Globalization;
+using System.Reflection;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.CoreModules.Avatar.Profiles
+{
+    public class AvatarProfilesModule : IRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private Scene m_scene;
+
+        public AvatarProfilesModule()
+        {
+        }
+
+        #region IRegionModule Members
+
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            m_scene = scene;
+            m_scene.EventManager.OnNewClient += NewClient;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "AvatarProfilesModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+
+        #endregion
+
+        public void NewClient(IClientAPI client)
+        {
+            client.OnRequestAvatarProperties += RequestAvatarProperty;
+            client.OnUpdateAvatarProperties += UpdateAvatarProperties;
+        }
+
+        public void RemoveClient(IClientAPI client)
+        {
+            client.OnRequestAvatarProperties -= RequestAvatarProperty;
+            client.OnUpdateAvatarProperties -= UpdateAvatarProperties;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="avatarID"></param>
+        public void RequestAvatarProperty(IClientAPI remoteClient, UUID avatarID)
+        {
+            // FIXME: finish adding fields such as url, masking, etc.
+            UserProfileData profile = m_scene.CommsManager.UserService.GetUserProfile(avatarID);
+            if (null != profile)
+            {
+                Byte[] charterMember;
+                if (profile.CustomType == "")
+                {
+                    charterMember = new Byte[1];
+                    charterMember[0] = (Byte)((profile.UserFlags & 0xf00) >> 8);
+                }
+                else
+                {
+                    charterMember = Utils.StringToBytes(profile.CustomType);
+                }
+
+                remoteClient.SendAvatarProperties(profile.ID, profile.AboutText,
+                                                  Util.ToDateTime(profile.Created).ToString("M/d/yyyy", CultureInfo.InvariantCulture),
+                                                  charterMember, profile.FirstLifeAboutText, (uint)(profile.UserFlags & 0xff),
+                                                  profile.FirstLifeImage, profile.Image, String.Empty, profile.Partner);
+            }
+            else
+            {
+                m_log.Debug("[AvatarProfilesModule]: Got null for profile for " + avatarID.ToString());
+            }
+        }
+
+        public void UpdateAvatarProperties(IClientAPI remoteClient, UserProfileData newProfile)
+        {
+            UserProfileData Profile = m_scene.CommsManager.UserService.GetUserProfile(newProfile.ID);
+
+            // if it's the profile of the user requesting the update, then we change only a few things.
+            if (remoteClient.AgentId.CompareTo(Profile.ID) == 0)
+            {
+                Profile.Image = newProfile.Image;
+                Profile.FirstLifeImage = newProfile.FirstLifeImage;
+                Profile.AboutText = newProfile.AboutText;
+                Profile.FirstLifeAboutText = newProfile.FirstLifeAboutText;
+            }
+            else
+            {
+                return;
+            }
+            
+            if (m_scene.CommsManager.UserService.UpdateUserProfile(Profile))
+            {
+                RequestAvatarProperty(remoteClient, newProfile.ID);
+            }
+        }
+    }
+}