Merge remote-tracking branch 'os/master'

6 files changed, 5262 insertions, 0 deletions

diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
new file mode 100644
index 0000000..e1b6abb
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
@@ -0,0 +1,704 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using PresenceInfo = OpenSim.Services.Interfaces.PresenceInfo;
+
+namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "GroupsMessagingModule")]
+    public class GroupsMessagingModule : ISharedRegionModule, IGroupsMessagingModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private List<Scene> m_sceneList = new List<Scene>();
+        private IPresenceService m_presenceService;
+
+        private IMessageTransferModule m_msgTransferModule = null;
+
+        private IGroupsServicesConnector m_groupData = null;
+
+        // Config Options
+        private bool m_groupMessagingEnabled;
+        private bool m_debugEnabled;
+
+        /// <summary>
+        /// If enabled, module only tries to send group IMs to online users by querying cached presence information.
+        /// </summary>
+        private bool m_messageOnlineAgentsOnly;
+
+        /// <summary>
+        /// Cache for online users.
+        /// </summary>
+        /// <remarks>
+        /// Group ID is key, presence information for online members is value.
+        /// Will only be non-null if m_messageOnlineAgentsOnly = true
+        /// We cache here so that group messages don't constantly have to re-request the online user list to avoid
+        /// attempted expensive sending of messages to offline users.
+        /// The tradeoff is that a user that comes online will not receive messages consistently from all other users
+        /// until caches have updated.
+        /// Therefore, we set the cache expiry to just 20 seconds.
+        /// </remarks>
+        private ExpiringCache<UUID, PresenceInfo[]> m_usersOnlineCache;
+
+        private int m_usersOnlineCacheExpirySeconds = 20;
+
+        #region Region Module interfaceBase Members
+
+        public void Initialise(IConfigSource config)
+        {
+            IConfig groupsConfig = config.Configs["Groups"];
+
+            if (groupsConfig == null)
+            {
+                // Do not run this module by default.
+                return;
+            }
+            else
+            {
+                // if groups aren't enabled, we're not needed.
+                // if we're not specified as the connector to use, then we're not wanted
+                if ((groupsConfig.GetBoolean("Enabled", false) == false)
+                     || (groupsConfig.GetString("MessagingModule", "") != Name))
+                {
+                    m_groupMessagingEnabled = false;
+                    return;
+                }
+
+                m_groupMessagingEnabled = groupsConfig.GetBoolean("MessagingEnabled", true);
+
+                if (!m_groupMessagingEnabled)
+                {
+                    return;
+                }
+
+                m_messageOnlineAgentsOnly = groupsConfig.GetBoolean("MessageOnlineUsersOnly", false);
+
+                if (m_messageOnlineAgentsOnly)
+                     m_usersOnlineCache = new ExpiringCache<UUID, PresenceInfo[]>();
+
+                m_debugEnabled = groupsConfig.GetBoolean("MessagingDebugEnabled", m_debugEnabled);
+            }
+
+            m_log.InfoFormat(
+                "[GROUPS-MESSAGING]: GroupsMessagingModule enabled with MessageOnlineOnly = {0}, DebugEnabled = {1}",
+                m_messageOnlineAgentsOnly, m_debugEnabled);
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_groupMessagingEnabled)
+                return;
+            
+            scene.RegisterModuleInterface<IGroupsMessagingModule>(this);
+
+            scene.AddCommand(
+                "Debug",
+                this,
+                "debug groups messaging verbose",
+                "debug groups messaging verbose <true|false>",
+                "This setting turns on very verbose groups messaging debugging",
+                HandleDebugGroupsMessagingVerbose);
+        }
+        
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_groupMessagingEnabled)
+                return;
+
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            m_groupData = scene.RequestModuleInterface<IGroupsServicesConnector>();
+
+            // No groups module, no groups messaging
+            if (m_groupData == null)
+            {
+                m_log.Error("[GROUPS-MESSAGING]: Could not get IGroupsServicesConnector, GroupsMessagingModule is now disabled.");
+                Close();
+                m_groupMessagingEnabled = false;
+                return;
+            }
+
+            m_msgTransferModule = scene.RequestModuleInterface<IMessageTransferModule>();
+
+            // No message transfer module, no groups messaging
+            if (m_msgTransferModule == null)
+            {
+                m_log.Error("[GROUPS-MESSAGING]: Could not get MessageTransferModule");
+                Close();
+                m_groupMessagingEnabled = false;
+                return;
+            }
+
+            if (m_presenceService == null)
+                m_presenceService = scene.PresenceService;
+
+            m_sceneList.Add(scene);
+
+            scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
+            scene.EventManager.OnClientLogin += OnClientLogin;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_groupMessagingEnabled)
+                return;
+
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            m_sceneList.Remove(scene);
+        }
+
+        public void Close()
+        {
+            if (!m_groupMessagingEnabled)
+                return;
+
+            if (m_debugEnabled) m_log.Debug("[GROUPS-MESSAGING]: Shutting down GroupsMessagingModule module.");
+
+            foreach (Scene scene in m_sceneList)
+            {
+                scene.EventManager.OnNewClient -= OnNewClient;
+                scene.EventManager.OnIncomingInstantMessage -= OnGridInstantMessage;
+            }
+
+            m_sceneList.Clear();
+
+            m_groupData = null;
+            m_msgTransferModule = null;
+        }
+
+        public Type ReplaceableInterface 
+        {
+            get { return null; }
+        }
+
+        public string Name
+        {
+            get { return "GroupsMessagingModule"; }
+        }
+
+        #endregion
+
+        #region ISharedRegionModule Members
+
+        public void PostInitialise()
+        {
+            // NoOp
+        }
+
+        #endregion
+
+        private void HandleDebugGroupsMessagingVerbose(object modules, string[] args)
+        {
+            if (args.Length < 5)
+            {
+                MainConsole.Instance.Output("Usage: debug groups messaging verbose <true|false>");
+                return;
+            }
+
+            bool verbose = false;
+            if (!bool.TryParse(args[4], out verbose))
+            {
+                MainConsole.Instance.Output("Usage: debug groups messaging verbose <true|false>");
+                return;
+            }
+
+            m_debugEnabled = verbose;
+
+            MainConsole.Instance.OutputFormat("{0} verbose logging set to {1}", Name, m_debugEnabled);
+        }
+
+        /// <summary>
+        /// Not really needed, but does confirm that the group exists.
+        /// </summary>
+        public bool StartGroupChatSession(UUID agentID, UUID groupID)
+        {
+            if (m_debugEnabled)
+                m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+                
+            GroupRecord groupInfo = m_groupData.GetGroupRecord(agentID, groupID, null);
+
+            if (groupInfo != null)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public void SendMessageToGroup(GridInstantMessage im, UUID groupID)
+        {
+            SendMessageToGroup(im, groupID, new UUID(im.fromAgentID), null);
+        }
+        
+        public void SendMessageToGroup(
+            GridInstantMessage im, UUID groupID, UUID sendingAgentForGroupCalls, Func<GroupMembersData, bool> sendCondition)
+        {
+            int requestStartTick = Environment.TickCount;
+
+            List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers(sendingAgentForGroupCalls, groupID);
+            int groupMembersCount = groupMembers.Count;
+            HashSet<string> attemptDeliveryUuidSet = null;
+
+            if (m_messageOnlineAgentsOnly)
+            {
+                string[] t1 = groupMembers.ConvertAll<string>(gmd => gmd.AgentID.ToString()).ToArray();
+
+                // We cache in order not to overwhlem the presence service on large grids with many groups.  This does
+                // mean that members coming online will not see all group members until after m_usersOnlineCacheExpirySeconds has elapsed.
+                // (assuming this is the same across all grid simulators).
+                PresenceInfo[] onlineAgents;
+                if (!m_usersOnlineCache.TryGetValue(groupID, out onlineAgents))
+                {
+                    onlineAgents = m_presenceService.GetAgents(t1);
+                    m_usersOnlineCache.Add(groupID, onlineAgents, m_usersOnlineCacheExpirySeconds);
+                }
+
+                attemptDeliveryUuidSet 
+                    = new HashSet<string>(Array.ConvertAll<PresenceInfo, string>(onlineAgents, pi => pi.UserID));
+
+                //Array.ForEach<PresenceInfo>(onlineAgents, pi => attemptDeliveryUuidSet.Add(pi.UserID));
+
+                //groupMembers = groupMembers.Where(gmd => onlineAgentsUuidSet.Contains(gmd.AgentID.ToString())).ToList();
+
+    //            if (m_debugEnabled)
+//                    m_log.DebugFormat(
+//                        "[GROUPS-MESSAGING]: SendMessageToGroup called for group {0} with {1} visible members, {2} online",
+//                        groupID, groupMembersCount, groupMembers.Count());
+            }
+            else
+            {
+                attemptDeliveryUuidSet 
+                    = new HashSet<string>(groupMembers.ConvertAll<string>(gmd => gmd.AgentID.ToString()));
+
+                if (m_debugEnabled)
+                    m_log.DebugFormat(
+                        "[GROUPS-MESSAGING]: SendMessageToGroup called for group {0} with {1} visible members",
+                        groupID, groupMembers.Count);
+            }           
+
+            foreach (GroupMembersData member in groupMembers)
+            {
+                if (sendCondition != null)
+                {
+                    if (!sendCondition(member))
+                    {
+                        if (m_debugEnabled) 
+                            m_log.DebugFormat(
+                                "[GROUPS-MESSAGING]: Not sending to {0} as they do not fulfill send condition", 
+                                 member.AgentID);
+
+                        continue;
+                    }
+                }
+                else if (m_groupData.hasAgentDroppedGroupChatSession(member.AgentID, groupID))
+                {
+                    // Don't deliver messages to people who have dropped this session
+                    if (m_debugEnabled) 
+                        m_log.DebugFormat(
+                            "[GROUPS-MESSAGING]: {0} has dropped session, not delivering to them", member.AgentID);
+
+                    continue;
+                }
+
+                // Copy Message
+                GridInstantMessage msg = new GridInstantMessage();
+                msg.imSessionID = im.imSessionID;
+                msg.fromAgentName = im.fromAgentName;
+                msg.message = im.message;
+                msg.dialog = im.dialog;
+                msg.offline = im.offline;
+                msg.ParentEstateID = im.ParentEstateID;
+                msg.Position = im.Position;
+                msg.RegionID = im.RegionID;
+                msg.binaryBucket = im.binaryBucket;
+                msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
+
+                msg.fromAgentID = im.fromAgentID;
+                msg.fromGroup = true;
+
+                msg.toAgentID = member.AgentID.Guid;
+
+                if (attemptDeliveryUuidSet.Contains(member.AgentID.ToString()))
+                {
+                    IClientAPI client = GetActiveClient(member.AgentID);
+                    if (client == null)
+                    {
+                        int startTick = Environment.TickCount;
+
+                        // If they're not local, forward across the grid
+                        m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { });
+
+                        if (m_debugEnabled) 
+                            m_log.DebugFormat(
+                                "[GROUPS-MESSAGING]: Delivering to {0} via grid took {1} ms", 
+                                member.AgentID, Environment.TickCount - startTick);
+                    }
+                    else
+                    {
+                        int startTick = Environment.TickCount;
+
+                        ProcessMessageFromGroupSession(msg, client);
+
+                        // Deliver locally, directly
+                        if (m_debugEnabled) 
+                            m_log.DebugFormat(
+                                "[GROUPS-MESSAGING]: Delivering to {0} locally took {1} ms", 
+                                member.AgentID, Environment.TickCount - startTick);
+                    }
+                }
+                else
+                {
+                    int startTick = Environment.TickCount;
+
+                    m_msgTransferModule.HandleUndeliverableMessage(msg, delegate(bool success) { });
+
+                    if (m_debugEnabled) 
+                        m_log.DebugFormat(
+                            "[GROUPS-MESSAGING]: Handling undeliverable message for {0} took {1} ms", 
+                            member.AgentID, Environment.TickCount - startTick);
+                }
+            }
+
+            if (m_debugEnabled)
+                m_log.DebugFormat(
+                    "[GROUPS-MESSAGING]: Total SendMessageToGroup for group {0} with {1} members, {2} candidates for delivery took {3} ms",
+                    groupID, groupMembersCount, attemptDeliveryUuidSet.Count(), Environment.TickCount - requestStartTick);
+        }
+        
+        #region SimGridEventHandlers
+
+        void OnClientLogin(IClientAPI client)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: OnInstantMessage registered for {0}", client.Name);
+        }
+
+        private void OnNewClient(IClientAPI client)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: OnInstantMessage registered for {0}", client.Name);
+
+            client.OnInstantMessage += OnInstantMessage;
+        }
+
+        private void OnGridInstantMessage(GridInstantMessage msg)
+        {
+            // The instant message module will only deliver messages of dialog types:
+            // MessageFromAgent, StartTyping, StopTyping, MessageFromObject
+            //
+            // Any other message type will not be delivered to a client by the 
+            // Instant Message Module
+
+            if (m_debugEnabled)
+            {
+                m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+                DebugGridInstantMessage(msg);
+            }
+
+            // Incoming message from a group
+            if ((msg.fromGroup == true) && 
+                ((msg.dialog == (byte)InstantMessageDialog.SessionSend)
+                 || (msg.dialog == (byte)InstantMessageDialog.SessionAdd)
+                 || (msg.dialog == (byte)InstantMessageDialog.SessionDrop)))
+            {
+                IClientAPI client = null;
+
+                if (msg.dialog == (byte)InstantMessageDialog.SessionSend)
+                {
+                    client = GetActiveClient(new UUID(msg.toAgentID));
+
+                    if (client != null)
+                    {
+                        if (m_debugEnabled) 
+                            m_log.DebugFormat("[GROUPS-MESSAGING]: Delivering to {0} locally", client.Name);
+                    } 
+                    else
+                    {
+                        m_log.WarnFormat("[GROUPS-MESSAGING]: Received a message over the grid for a client that isn't here: {0}", msg.toAgentID);
+
+                        return;
+                    }
+                }
+
+                ProcessMessageFromGroupSession(msg, client);
+            }
+        }
+
+        private void ProcessMessageFromGroupSession(GridInstantMessage msg, IClientAPI client)
+        {
+            if (m_debugEnabled) 
+                m_log.DebugFormat(
+                    "[GROUPS-MESSAGING]: Session message from {0} going to agent {1}, sessionID {2}, type {3}",
+                    msg.fromAgentName, msg.toAgentID, msg.imSessionID, (InstantMessageDialog)msg.dialog);
+
+            UUID AgentID = new UUID(msg.fromAgentID);
+            UUID GroupID = new UUID(msg.imSessionID);
+
+            switch (msg.dialog)
+            {
+                case (byte)InstantMessageDialog.SessionAdd:
+                    m_groupData.AgentInvitedToGroupChatSession(AgentID, GroupID);
+                    break;
+
+                case (byte)InstantMessageDialog.SessionDrop:
+                    m_groupData.AgentDroppedFromGroupChatSession(AgentID, GroupID);
+                    break;
+
+                case (byte)InstantMessageDialog.SessionSend:
+                    if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID, GroupID)
+                        && !m_groupData.hasAgentBeenInvitedToGroupChatSession(AgentID, GroupID)
+                        )
+                    {
+                        // Agent not in session and hasn't dropped from session
+                        // Add them to the session for now, and Invite them
+                        m_groupData.AgentInvitedToGroupChatSession(AgentID, GroupID);
+
+                        GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero, GroupID, null);
+                        if (groupInfo != null)
+                        {
+                            if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: Sending chatterbox invite instant message");
+
+                            // Force? open the group session dialog???
+                            // and simultanously deliver the message, so we don't need to do a seperate client.SendInstantMessage(msg);
+                            IEventQueue eq = client.Scene.RequestModuleInterface<IEventQueue>();
+                            eq.ChatterboxInvitation(
+                                GroupID
+                                , groupInfo.GroupName
+                                , new UUID(msg.fromAgentID)
+                                , msg.message
+                                , new UUID(msg.toAgentID)
+                                , msg.fromAgentName
+                                , msg.dialog
+                                , msg.timestamp
+                                , msg.offline == 1
+                                , (int)msg.ParentEstateID
+                                , msg.Position
+                                , 1
+                                , new UUID(msg.imSessionID)
+                                , msg.fromGroup
+                                , Utils.StringToBytes(groupInfo.GroupName)
+                                );
+
+                            eq.ChatterBoxSessionAgentListUpdates(
+                                new UUID(GroupID)
+                                , new UUID(msg.fromAgentID)
+                                , new UUID(msg.toAgentID)
+                                , false //canVoiceChat
+                                , false //isModerator
+                                , false //text mute
+                                );
+                        }
+
+                        break;
+                    }
+                    else if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID, GroupID))
+                    {
+                        // User hasn't dropped, so they're in the session, 
+                        // maybe we should deliver it.
+                        client.SendInstantMessage(msg);
+                    }
+
+                    break;
+
+                default:
+                    client.SendInstantMessage(msg);
+
+                    break;;
+            }
+        }
+
+        #endregion
+
+        #region ClientEvents
+        private void OnInstantMessage(IClientAPI remoteClient, GridInstantMessage im)
+        {
+            if (m_debugEnabled)
+            {
+                m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+                DebugGridInstantMessage(im);
+            }
+
+            // Start group IM session
+            if ((im.dialog == (byte)InstantMessageDialog.SessionGroupStart))
+            {
+                if (m_debugEnabled) m_log.InfoFormat("[GROUPS-MESSAGING]: imSessionID({0}) toAgentID({1})", im.imSessionID, im.toAgentID);
+
+                UUID GroupID = new UUID(im.imSessionID);
+                UUID AgentID = new UUID(im.fromAgentID);
+
+                GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero, GroupID, null);
+    
+                if (groupInfo != null)
+                {
+                    m_groupData.AgentInvitedToGroupChatSession(AgentID, GroupID);
+
+                    ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, GroupID);
+
+                    IEventQueue queue = remoteClient.Scene.RequestModuleInterface<IEventQueue>();
+                    queue.ChatterBoxSessionAgentListUpdates(
+                        GroupID
+                        , AgentID
+                        , new UUID(im.toAgentID)
+                        , false //canVoiceChat
+                        , false //isModerator
+                        , false //text mute
+                        );
+                }
+            }
+
+            // Send a message from locally connected client to a group
+            if ((im.dialog == (byte)InstantMessageDialog.SessionSend))
+            {
+                UUID GroupID = new UUID(im.imSessionID);
+                UUID AgentID = new UUID(im.fromAgentID);
+
+                if (m_debugEnabled) 
+                    m_log.DebugFormat("[GROUPS-MESSAGING]: Send message to session for group {0} with session ID {1}", GroupID, im.imSessionID.ToString());
+
+                //If this agent is sending a message, then they want to be in the session
+                m_groupData.AgentInvitedToGroupChatSession(AgentID, GroupID);
+
+                SendMessageToGroup(im, GroupID);
+            }
+        }
+
+        #endregion
+
+        void ChatterBoxSessionStartReplyViaCaps(IClientAPI remoteClient, string groupName, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS-MESSAGING]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap moderatedMap = new OSDMap(4);
+            moderatedMap.Add("voice", OSD.FromBoolean(false));
+
+            OSDMap sessionMap = new OSDMap(4);
+            sessionMap.Add("moderated_mode", moderatedMap);
+            sessionMap.Add("session_name", OSD.FromString(groupName));
+            sessionMap.Add("type", OSD.FromInteger(0));
+            sessionMap.Add("voice_enabled", OSD.FromBoolean(false));
+
+            OSDMap bodyMap = new OSDMap(4);
+            bodyMap.Add("session_id", OSD.FromUUID(groupID));
+            bodyMap.Add("temp_session_id", OSD.FromUUID(groupID));
+            bodyMap.Add("success", OSD.FromBoolean(true));
+            bodyMap.Add("session_info", sessionMap);
+
+            IEventQueue queue = remoteClient.Scene.RequestModuleInterface<IEventQueue>();
+
+            if (queue != null)
+            {
+                queue.Enqueue(queue.BuildEvent("ChatterBoxSessionStartReply", bodyMap), remoteClient.AgentId);
+            }
+        }
+
+        private void DebugGridInstantMessage(GridInstantMessage im)
+        {
+            // Don't log any normal IMs (privacy!)
+            if (m_debugEnabled && im.dialog != (byte)InstantMessageDialog.MessageFromAgent)
+            {
+                m_log.DebugFormat("[GROUPS-MESSAGING]: IM: fromGroup({0})", im.fromGroup ? "True" : "False");
+                m_log.DebugFormat("[GROUPS-MESSAGING]: IM: Dialog({0})", (InstantMessageDialog)im.dialog);
+                m_log.DebugFormat("[GROUPS-MESSAGING]: IM: fromAgentID({0})", im.fromAgentID);
+                m_log.DebugFormat("[GROUPS-MESSAGING]: IM: fromAgentName({0})", im.fromAgentName);
+                m_log.DebugFormat("[GROUPS-MESSAGING]: IM: imSessionID({0})", im.imSessionID);
+                m_log.DebugFormat("[GROUPS-MESSAGING]: IM: message({0})", im.message);
+                m_log.DebugFormat("[GROUPS-MESSAGING]: IM: offline({0})", im.offline);
+                m_log.DebugFormat("[GROUPS-MESSAGING]: IM: toAgentID({0})", im.toAgentID);
+                m_log.DebugFormat("[GROUPS-MESSAGING]: IM: binaryBucket({0})", OpenMetaverse.Utils.BytesToHexString(im.binaryBucket, "BinaryBucket"));
+            }
+        }
+
+        #region Client Tools
+
+        /// <summary>
+        /// Try to find an active IClientAPI reference for agentID giving preference to root connections
+        /// </summary>
+        private IClientAPI GetActiveClient(UUID agentID)
+        {
+            if (m_debugEnabled) 
+                m_log.DebugFormat("[GROUPS-MESSAGING]: Looking for local client {0}", agentID);
+
+            IClientAPI child = null;
+
+            // Try root avatar first
+            foreach (Scene scene in m_sceneList)
+            {
+                ScenePresence sp = scene.GetScenePresence(agentID);
+                if (sp != null)
+                {
+                    if (!sp.IsChildAgent)
+                    {
+                        if (m_debugEnabled) 
+                            m_log.DebugFormat("[GROUPS-MESSAGING]: Found root agent for client : {0}", sp.ControllingClient.Name);
+
+                        return sp.ControllingClient;
+                    }
+                    else
+                    {
+                        if (m_debugEnabled) 
+                            m_log.DebugFormat("[GROUPS-MESSAGING]: Found child agent for client : {0}", sp.ControllingClient.Name);
+
+                        child = sp.ControllingClient;
+                    }
+                }
+            }
+
+            // If we didn't find a root, then just return whichever child we found, or null if none
+            if (child == null)
+            {
+                if (m_debugEnabled) 
+                    m_log.DebugFormat("[GROUPS-MESSAGING]: Could not find local client for agent : {0}", agentID);
+            }
+            else
+            {
+                if (m_debugEnabled) 
+                    m_log.DebugFormat("[GROUPS-MESSAGING]: Returning child agent for client : {0}", child.Name);
+            }
+
+            return child;
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
new file mode 100644
index 0000000..dff3f78
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
@@ -0,0 +1,1554 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Timers;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using System.Text;
+using DirFindFlags = OpenMetaverse.DirectoryManager.DirFindFlags;
+
+namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "GroupsModule")]
+    public class GroupsModule : ISharedRegionModule, IGroupsModule
+    {
+        /// <summary>
+        /// ; To use this module, you must specify the following in your OpenSim.ini
+        /// [GROUPS]
+        /// Enabled = true
+        /// 
+        /// Module   = GroupsModule
+        /// NoticesEnabled = true
+        /// DebugEnabled   = true
+        /// 
+        /// GroupsServicesConnectorModule = XmlRpcGroupsServicesConnector
+        /// XmlRpcServiceURL      = http://osflotsam.org/xmlrpc.php
+        /// XmlRpcServiceReadKey  = 1234
+        /// XmlRpcServiceWriteKey = 1234
+        /// 
+        /// MessagingModule  = GroupsMessagingModule
+        /// MessagingEnabled = true
+        /// 
+        /// ; Disables HTTP Keep-Alive for Groups Module HTTP Requests, work around for
+        /// ; a problem discovered on some Windows based region servers.  Only disable
+        /// ; if you see a large number (dozens) of the following Exceptions:
+        /// ; System.Net.WebException: The request was aborted: The request was canceled.
+        ///
+        /// XmlRpcDisableKeepAlive = false
+        /// </summary>
+
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private List<Scene> m_sceneList = new List<Scene>();
+
+        private IMessageTransferModule m_msgTransferModule;
+
+        private IGroupsMessagingModule m_groupsMessagingModule;
+        
+        private IGroupsServicesConnector m_groupData;
+
+        // Configuration settings
+        private bool m_groupsEnabled = false;
+        private bool m_groupNoticesEnabled = true;
+        private bool m_debugEnabled = false;
+        private int  m_levelGroupCreate = 0;
+
+        #region Region Module interfaceBase Members
+
+        public void Initialise(IConfigSource config)
+        {
+            IConfig groupsConfig = config.Configs["Groups"];
+
+            if (groupsConfig == null)
+            {
+                // Do not run this module by default.
+                return;
+            }
+            else
+            {
+                m_groupsEnabled = groupsConfig.GetBoolean("Enabled", false);
+                if (!m_groupsEnabled)
+                {
+                    return;
+                }
+
+                if (groupsConfig.GetString("Module", "Default") != Name)
+                {
+                    m_groupsEnabled = false;
+
+                    return;
+                }
+
+                m_log.InfoFormat("[GROUPS]: Initializing {0}", this.Name);
+
+                m_groupNoticesEnabled   = groupsConfig.GetBoolean("NoticesEnabled", true);
+                m_debugEnabled          = groupsConfig.GetBoolean("DebugEnabled", false);
+                m_levelGroupCreate      = groupsConfig.GetInt("LevelGroupCreate", 0);
+            }
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (m_groupsEnabled)
+            {
+                scene.RegisterModuleInterface<IGroupsModule>(this);
+                scene.AddCommand(
+                    "Debug",
+                    this,
+                    "debug groups verbose",
+                    "debug groups verbose <true|false>",
+                    "This setting turns on very verbose groups debugging",
+                    HandleDebugGroupsVerbose);
+            }
+        }
+
+        private void HandleDebugGroupsVerbose(object modules, string[] args)
+        {
+            if (args.Length < 4)
+            {
+                MainConsole.Instance.Output("Usage: debug groups verbose <true|false>");
+                return;
+            }
+
+            bool verbose = false;
+            if (!bool.TryParse(args[3], out verbose))
+            {
+                MainConsole.Instance.Output("Usage: debug groups verbose <true|false>");
+                return;
+            }
+
+            m_debugEnabled = verbose;
+
+            MainConsole.Instance.OutputFormat("{0} verbose logging set to {1}", Name, m_debugEnabled);
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_groupsEnabled)
+                return;
+
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            if (m_groupData == null)
+            {
+                m_groupData = scene.RequestModuleInterface<IGroupsServicesConnector>();
+
+                // No Groups Service Connector, then nothing works...
+                if (m_groupData == null)
+                {
+                    m_groupsEnabled = false;
+                    m_log.Error("[GROUPS]: Could not get IGroupsServicesConnector");
+                    Close();
+                    return;
+                }
+            }
+
+            if (m_msgTransferModule == null)
+            {
+                m_msgTransferModule = scene.RequestModuleInterface<IMessageTransferModule>();
+
+                // No message transfer module, no notices, group invites, rejects, ejects, etc
+                if (m_msgTransferModule == null)
+                {
+                    m_groupsEnabled = false;
+                    m_log.Warn("[GROUPS]: Could not get IMessageTransferModule");
+                }
+            }
+
+            if (m_groupsMessagingModule == null)
+            {
+                m_groupsMessagingModule = scene.RequestModuleInterface<IGroupsMessagingModule>();
+
+                // No message transfer module, no notices, group invites, rejects, ejects, etc
+                if (m_groupsMessagingModule == null)
+                    m_log.Warn("[GROUPS]: Could not get IGroupsMessagingModule");
+            }
+
+            lock (m_sceneList)
+            {
+                m_sceneList.Add(scene);
+            }
+
+            scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
+            // The InstantMessageModule itself doesn't do this, 
+            // so lets see if things explode if we don't do it
+            // scene.EventManager.OnClientClosed += OnClientClosed;
+
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_groupsEnabled)
+                return;
+
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            lock (m_sceneList)
+            {
+                m_sceneList.Remove(scene);
+            }
+        }
+
+        public void Close()
+        {
+            if (!m_groupsEnabled)
+                return;
+
+            if (m_debugEnabled) m_log.Debug("[GROUPS]: Shutting down Groups module.");
+        }
+
+        public Type ReplaceableInterface 
+        {
+            get { return null; }
+        }
+
+        public string Name
+        {
+            get { return "GroupsModule"; }
+        }
+
+        #endregion
+
+        #region ISharedRegionModule Members
+
+        public void PostInitialise()
+        {
+            // NoOp
+        }
+
+        #endregion
+
+        #region EventHandlers
+        private void OnNewClient(IClientAPI client)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            client.OnUUIDGroupNameRequest += HandleUUIDGroupNameRequest;
+            client.OnAgentDataUpdateRequest += OnAgentDataUpdateRequest;
+            client.OnRequestAvatarProperties += OnRequestAvatarProperties;
+
+            // Used for Notices and Group Invites/Accept/Reject
+            client.OnInstantMessage += OnInstantMessage;
+
+            // Send client their groups information.
+            SendAgentGroupDataUpdate(client, client.AgentId);
+        }
+
+        private void OnRequestAvatarProperties(IClientAPI remoteClient, UUID avatarID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            //GroupMembershipData[] avatarGroups = m_groupData.GetAgentGroupMemberships(GetRequestingAgentID(remoteClient), avatarID).ToArray();
+            GroupMembershipData[] avatarGroups = GetProfileListedGroupMemberships(remoteClient, avatarID);
+            remoteClient.SendAvatarGroupsReply(avatarID, avatarGroups);
+        }
+
+        /*
+         * This becomes very problematic in a shared module.  In a shared module you may have more then one
+         * reference to IClientAPI's, one for 0 or 1 root connections, and 0 or more child connections.
+         * The OnClientClosed event does not provide anything to indicate which one of those should be closed
+         * nor does it provide what scene it was from so that the specific reference can be looked up.
+         * The InstantMessageModule.cs does not currently worry about unregistering the handles, 
+         * and it should be an issue, since it's the client that references us not the other way around
+         * , so as long as we don't keep a reference to the client laying around, the client can still be GC'ed
+        private void OnClientClosed(UUID AgentId)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            lock (m_ActiveClients)
+            {
+                if (m_ActiveClients.ContainsKey(AgentId))
+                {
+                    IClientAPI client = m_ActiveClients[AgentId];
+                    client.OnUUIDGroupNameRequest -= HandleUUIDGroupNameRequest;
+                    client.OnAgentDataUpdateRequest -= OnAgentDataUpdateRequest;
+                    client.OnDirFindQuery -= OnDirFindQuery;
+                    client.OnInstantMessage -= OnInstantMessage;
+
+                    m_ActiveClients.Remove(AgentId);
+                }
+                else
+                {
+                    if (m_debugEnabled) m_log.WarnFormat("[GROUPS]: Client closed that wasn't registered here.");
+                }
+
+                
+            }
+        }
+        */
+
+        private void OnAgentDataUpdateRequest(IClientAPI remoteClient, UUID dataForAgentID, UUID sessionID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            UUID activeGroupID = UUID.Zero;
+            string activeGroupTitle = string.Empty;
+            string activeGroupName = string.Empty;
+            ulong activeGroupPowers  = (ulong)GroupPowers.None;
+
+            GroupMembershipData membership = m_groupData.GetAgentActiveMembership(GetRequestingAgentID(remoteClient), dataForAgentID);
+            if (membership != null)
+            {
+                activeGroupID = membership.GroupID;
+                activeGroupTitle = membership.GroupTitle;
+                activeGroupPowers = membership.GroupPowers;
+            }
+
+            SendAgentDataUpdate(remoteClient, dataForAgentID, activeGroupID, activeGroupName, activeGroupPowers, activeGroupTitle);
+
+            SendScenePresenceUpdate(dataForAgentID, activeGroupTitle);
+        }
+
+        private void HandleUUIDGroupNameRequest(UUID GroupID, IClientAPI remoteClient)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            string GroupName;
+            
+            GroupRecord group = m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), GroupID, null);
+            if (group != null)
+            {
+                GroupName = group.GroupName;
+            }
+            else
+            {
+                GroupName = "Unknown";
+            }
+
+            remoteClient.SendGroupNameReply(GroupID, GroupName);
+        }
+
+        private void OnInstantMessage(IClientAPI remoteClient, GridInstantMessage im)
+        {
+            if (m_debugEnabled) 
+                m_log.DebugFormat(
+                    "[GROUPS]: {0} called for {1}, message type {2}", 
+                    System.Reflection.MethodBase.GetCurrentMethod().Name, remoteClient.Name, (InstantMessageDialog)im.dialog);
+
+            // Group invitations
+            if ((im.dialog == (byte)InstantMessageDialog.GroupInvitationAccept) || (im.dialog == (byte)InstantMessageDialog.GroupInvitationDecline))
+            {
+                UUID inviteID = new UUID(im.imSessionID);
+                GroupInviteInfo inviteInfo = m_groupData.GetAgentToGroupInvite(GetRequestingAgentID(remoteClient), inviteID);
+
+                if (inviteInfo == null)
+                {
+                    if (m_debugEnabled) m_log.WarnFormat("[GROUPS]: Received an Invite IM for an invite that does not exist {0}.", inviteID);
+                    return;
+                }
+
+                if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Invite is for Agent {0} to Group {1}.", inviteInfo.AgentID, inviteInfo.GroupID);
+
+                UUID fromAgentID = new UUID(im.fromAgentID);
+                if ((inviteInfo != null) && (fromAgentID == inviteInfo.AgentID))
+                {
+                    // Accept
+                    if (im.dialog == (byte)InstantMessageDialog.GroupInvitationAccept)
+                    {
+                        if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Received an accept invite notice.");
+
+                        // and the sessionid is the role
+                        m_groupData.AddAgentToGroup(GetRequestingAgentID(remoteClient), inviteInfo.AgentID, inviteInfo.GroupID, inviteInfo.RoleID);
+
+                        GridInstantMessage msg = new GridInstantMessage();
+                        msg.imSessionID = UUID.Zero.Guid;
+                        msg.fromAgentID = UUID.Zero.Guid;
+                        msg.toAgentID = inviteInfo.AgentID.Guid;
+                        msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
+                        msg.fromAgentName = "Groups";
+                        msg.message = string.Format("You have been added to the group.");
+                        msg.dialog = (byte)OpenMetaverse.InstantMessageDialog.MessageBox;
+                        msg.fromGroup = false;
+                        msg.offline = (byte)0;
+                        msg.ParentEstateID = 0;
+                        msg.Position = Vector3.Zero;
+                        msg.RegionID = UUID.Zero.Guid;
+                        msg.binaryBucket = new byte[0];
+
+                        OutgoingInstantMessage(msg, inviteInfo.AgentID);
+
+                        UpdateAllClientsWithGroupInfo(inviteInfo.AgentID);
+
+                        // TODO: If the inviter is still online, they need an agent dataupdate 
+                        // and maybe group membership updates for the invitee
+
+                        m_groupData.RemoveAgentToGroupInvite(GetRequestingAgentID(remoteClient), inviteID);
+                    }
+
+                    // Reject
+                    if (im.dialog == (byte)InstantMessageDialog.GroupInvitationDecline)
+                    {
+                        if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Received a reject invite notice.");
+                        m_groupData.RemoveAgentToGroupInvite(GetRequestingAgentID(remoteClient), inviteID);
+                    }
+                }
+            }
+
+            // Group notices
+            if ((im.dialog == (byte)InstantMessageDialog.GroupNotice))
+            {
+                if (!m_groupNoticesEnabled)
+                {
+                    return;
+                }
+
+                UUID GroupID = new UUID(im.toAgentID);
+                if (m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), GroupID, null) != null)
+                {
+                    UUID NoticeID = UUID.Random();
+                    string Subject = im.message.Substring(0, im.message.IndexOf('|'));
+                    string Message = im.message.Substring(Subject.Length + 1);
+
+                    InventoryItemBase item = null;
+                    bool hasAttachment = false;
+                    UUID itemID = UUID.Zero;    //Assignment to quiet compiler
+                    UUID ownerID = UUID.Zero;   //Assignment to quiet compiler
+                    byte[] bucket;
+
+                    if (im.binaryBucket.Length >= 1 && im.binaryBucket[0] > 0)
+                    {
+                        string binBucket = OpenMetaverse.Utils.BytesToString(im.binaryBucket);
+                        binBucket = binBucket.Remove(0, 14).Trim();
+
+                        OSDMap binBucketOSD = (OSDMap)OSDParser.DeserializeLLSDXml(binBucket);
+                        if (binBucketOSD is OSD)
+                        {
+                            OSDMap binBucketMap = (OSDMap)binBucketOSD;
+
+                            itemID = binBucketMap["item_id"].AsUUID();
+                            ownerID = binBucketMap["owner_id"].AsUUID();
+
+                            //Attempt to get the details of the attached item.
+                            //If sender doesn't own the attachment, the item
+                            //variable will be set to null and attachment will
+                            //not be included with the group notice.
+                            Scene scene = (Scene)remoteClient.Scene;
+                            item = new InventoryItemBase(itemID, ownerID);
+                            item = scene.InventoryService.GetItem(item);
+
+                            if (item != null)
+                            {
+                                //Got item details so include the attachment.
+                                hasAttachment = true;
+                            }
+                        }
+                        else
+                        {
+                            m_log.DebugFormat("[Groups]: Received OSD with unexpected type: {0}", binBucketOSD.GetType());
+                        }
+                    }
+
+                    if (hasAttachment)
+                    {
+                        //Bucket contains information about attachment.
+                        //
+                        //Byte offset and description of bucket data:
+                        //0:  1 byte indicating if attachment is present
+                        //1:  1 byte indicating the type of attachment
+                        //2:  16 bytes - Group UUID
+                        //18: 16 bytes - UUID of the attachment owner
+                        //34: 16 bytes - UUID of the attachment
+                        //50: variable - Name of the attachment
+                        //??: NUL byte to terminate the attachment name
+                        byte[] name = Encoding.UTF8.GetBytes(item.Name);
+                        bucket = new byte[51 + name.Length];//3 bytes, 3 UUIDs, and name
+                        bucket[0] = 1;                      //Has attachment flag
+                        bucket[1] = (byte)item.InvType;     //Type of Attachment
+                        GroupID.ToBytes(bucket, 2);
+                        ownerID.ToBytes(bucket, 18);
+                        itemID.ToBytes(bucket, 34);
+                        name.CopyTo(bucket, 50);
+                    }
+                    else
+                    {
+                        bucket = new byte[19];
+                        bucket[0] = 0;  //Has attachment flag
+                        bucket[1] = 0;  //Type of attachment
+                        GroupID.ToBytes(bucket, 2);
+                        bucket[18] = 0; //NUL terminate name of attachment
+                    }
+
+                    m_groupData.AddGroupNotice(GetRequestingAgentID(remoteClient), GroupID, NoticeID, im.fromAgentName, Subject, Message, bucket);
+                    if (OnNewGroupNotice != null)
+                    {
+                        OnNewGroupNotice(GroupID, NoticeID);
+                    }
+
+                    if (m_debugEnabled)
+                    {
+                        foreach (GroupMembersData member in m_groupData.GetGroupMembers(GetRequestingAgentID(remoteClient), GroupID))
+                        {
+                            if (m_debugEnabled)
+                            {
+                                UserAccount targetUser
+                                    = m_sceneList[0].UserAccountService.GetUserAccount(
+                                        remoteClient.Scene.RegionInfo.ScopeID, member.AgentID);
+
+                                if (targetUser != null)
+                                {
+                                    m_log.DebugFormat(
+                                        "[GROUPS]: Prepping group notice {0} for agent: {1} who Accepts Notices ({2})", 
+                                        NoticeID, targetUser.FirstName + " " + targetUser.LastName, member.AcceptNotices);
+                                }
+                                else
+                                {
+                                    m_log.DebugFormat(
+                                        "[GROUPS]: Prepping group notice {0} for agent: {1} who Accepts Notices ({2})", 
+                                        NoticeID, member.AgentID, member.AcceptNotices);
+                                }
+                            }
+                        }
+                    }
+
+                    GridInstantMessage msg 
+                        = CreateGroupNoticeIM(UUID.Zero, NoticeID, (byte)OpenMetaverse.InstantMessageDialog.GroupNotice);
+
+                    if (m_groupsMessagingModule != null)
+                        m_groupsMessagingModule.SendMessageToGroup(
+                            msg, GroupID, remoteClient.AgentId, gmd => gmd.AcceptNotices);
+                }
+            }
+
+            if (im.dialog == (byte)InstantMessageDialog.GroupNoticeInventoryAccepted)
+            {
+                //Is bucket large enough to hold UUID of the attachment?
+                if (im.binaryBucket.Length < 16)
+                    return;
+
+                UUID noticeID = new UUID(im.imSessionID);
+
+                if (m_debugEnabled) 
+                    m_log.DebugFormat("[GROUPS]: Requesting notice {0} for {1}", noticeID, remoteClient.AgentId);
+
+                GroupNoticeInfo notice = m_groupData.GetGroupNotice(GetRequestingAgentID(remoteClient), noticeID);
+                if (notice != null)
+                {
+                    UUID giver = new UUID(notice.BinaryBucket, 18);
+                    UUID attachmentUUID = new UUID(notice.BinaryBucket, 34);
+
+                    if (m_debugEnabled)
+                        m_log.DebugFormat("[Groups]: Giving inventory from {0} to {1}", giver, remoteClient.AgentId);
+
+                    string message;
+                    InventoryItemBase itemCopy = ((Scene)(remoteClient.Scene)).GiveInventoryItem(remoteClient.AgentId,
+                        giver, attachmentUUID, out message);
+
+                    if (itemCopy == null)
+                    {
+                        remoteClient.SendAgentAlertMessage(message, false);
+                        return;
+                    }
+
+                    remoteClient.SendInventoryItemCreateUpdate(itemCopy, 0);
+                }
+                else
+                {
+                    if (m_debugEnabled) 
+                        m_log.DebugFormat(
+                            "[GROUPS]: Could not find notice {0} for {1} on GroupNoticeInventoryAccepted.", 
+                            noticeID, remoteClient.AgentId);                   
+                }
+            }
+
+            // Interop, received special 210 code for ejecting a group member
+            // this only works within the comms servers domain, and won't work hypergrid
+            // TODO:FIXME: Use a presence server of some kind to find out where the
+            // client actually is, and try contacting that region directly to notify them,
+            // or provide the notification via xmlrpc update queue
+            if ((im.dialog == 210))
+            {
+                // This is sent from the region that the ejectee was ejected from
+                // if it's being delivered here, then the ejectee is here
+                // so we need to send local updates to the agent.
+
+                UUID ejecteeID = new UUID(im.toAgentID);
+
+                im.dialog = (byte)InstantMessageDialog.MessageFromAgent;
+                OutgoingInstantMessage(im, ejecteeID);
+
+                IClientAPI ejectee = GetActiveClient(ejecteeID);
+                if (ejectee != null)
+                {
+                    UUID groupID = new UUID(im.imSessionID);
+                    ejectee.SendAgentDropGroup(groupID);
+                }
+            }
+        }
+
+        private void OnGridInstantMessage(GridInstantMessage msg)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // Trigger the above event handler
+            OnInstantMessage(null, msg);
+
+            // If a message from a group arrives here, it may need to be forwarded to a local client
+            if (msg.fromGroup == true)
+            {
+                switch (msg.dialog)
+                {
+                    case (byte)InstantMessageDialog.GroupInvitation:
+                    case (byte)InstantMessageDialog.GroupNotice:
+                        UUID toAgentID = new UUID(msg.toAgentID);
+                        IClientAPI localClient = GetActiveClient(toAgentID);
+                        if (localClient != null)
+                        {
+                            localClient.SendInstantMessage(msg);
+                        }
+                        break;
+                }
+            }
+        }
+
+        #endregion
+
+        #region IGroupsModule Members
+
+        public event NewGroupNotice OnNewGroupNotice;
+
+        public GroupRecord GetGroupRecord(UUID GroupID)
+        {
+            return m_groupData.GetGroupRecord(UUID.Zero, GroupID, null);
+        }
+
+        public GroupRecord GetGroupRecord(string name)
+        {
+            return m_groupData.GetGroupRecord(UUID.Zero, UUID.Zero, name);
+        }
+        
+        public void ActivateGroup(IClientAPI remoteClient, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            m_groupData.SetAgentActiveGroup(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
+
+            // Changing active group changes title, active powers, all kinds of things
+            // anyone who is in any region that can see this client, should probably be 
+            // updated with new group info.  At a minimum, they should get ScenePresence
+            // updated with new title.
+            UpdateAllClientsWithGroupInfo(GetRequestingAgentID(remoteClient));
+        }
+
+        /// <summary>
+        /// Get the Role Titles for an Agent, for a specific group
+        /// </summary>
+        public List<GroupTitlesData> GroupTitlesRequest(IClientAPI remoteClient, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+
+            List<GroupRolesData> agentRoles = m_groupData.GetAgentGroupRoles(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
+            GroupMembershipData agentMembership = m_groupData.GetAgentGroupMembership(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
+
+            List<GroupTitlesData> titles = new List<GroupTitlesData>();
+            foreach (GroupRolesData role in agentRoles)
+            {
+                GroupTitlesData title = new GroupTitlesData();
+                title.Name = role.Name;
+                if (agentMembership != null)
+                {
+                    title.Selected = agentMembership.ActiveRole == role.RoleID;
+                }
+                title.UUID = role.RoleID;
+
+                titles.Add(title);
+            }
+
+            return titles;
+        }
+
+        public List<GroupMembersData> GroupMembersRequest(IClientAPI remoteClient, UUID groupID)
+        {
+            if (m_debugEnabled) 
+                m_log.DebugFormat(
+                    "[GROUPS]: GroupMembersRequest called for {0} from client {1}", groupID, remoteClient.Name);
+            
+            List<GroupMembersData> data = m_groupData.GetGroupMembers(GetRequestingAgentID(remoteClient), groupID);
+
+            if (m_debugEnabled)
+            {
+                foreach (GroupMembersData member in data)
+                {
+                    m_log.DebugFormat("[GROUPS]: Member({0}) - IsOwner({1})", member.AgentID, member.IsOwner);
+                }
+            }
+
+            return data;
+
+        }
+
+        public List<GroupRolesData> GroupRoleDataRequest(IClientAPI remoteClient, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            List<GroupRolesData> data = m_groupData.GetGroupRoles(GetRequestingAgentID(remoteClient), groupID);
+
+            return data;
+        }
+
+        public List<GroupRoleMembersData> GroupRoleMembersRequest(IClientAPI remoteClient, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            List<GroupRoleMembersData> data = m_groupData.GetGroupRoleMembers(GetRequestingAgentID(remoteClient), groupID);
+
+            if (m_debugEnabled)
+            {
+                foreach (GroupRoleMembersData member in data)
+                {
+                    m_log.DebugFormat("[GROUPS]: Member({0}) - Role({1})", member.MemberID, member.RoleID);
+                }
+            }
+            return data;
+        }
+
+        public GroupProfileData GroupProfileRequest(IClientAPI remoteClient, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            GroupProfileData profile = new GroupProfileData();
+
+
+            GroupRecord groupInfo = m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), groupID, null);
+            if (groupInfo != null)
+            {
+                profile.AllowPublish = groupInfo.AllowPublish;
+                profile.Charter = groupInfo.Charter;
+                profile.FounderID = groupInfo.FounderID;
+                profile.GroupID = groupID;
+                profile.GroupMembershipCount = m_groupData.GetGroupMembers(GetRequestingAgentID(remoteClient), groupID).Count;
+                profile.GroupRolesCount = m_groupData.GetGroupRoles(GetRequestingAgentID(remoteClient), groupID).Count;
+                profile.InsigniaID = groupInfo.GroupPicture;
+                profile.MaturePublish = groupInfo.MaturePublish;
+                profile.MembershipFee = groupInfo.MembershipFee;
+                profile.Money = 0; // TODO: Get this from the currency server?
+                profile.Name = groupInfo.GroupName;
+                profile.OpenEnrollment = groupInfo.OpenEnrollment;
+                profile.OwnerRole = groupInfo.OwnerRoleID;
+                profile.ShowInList = groupInfo.ShowInList;
+            }
+
+            GroupMembershipData memberInfo = m_groupData.GetAgentGroupMembership(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
+            if (memberInfo != null)
+            {
+                profile.MemberTitle = memberInfo.GroupTitle;
+                profile.PowersMask = memberInfo.GroupPowers;
+            }
+
+            return profile;
+        }
+
+        public GroupMembershipData[] GetMembershipData(UUID agentID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            return m_groupData.GetAgentGroupMemberships(UUID.Zero, agentID).ToArray();
+        }
+
+        public GroupMembershipData GetMembershipData(UUID groupID, UUID agentID)
+        {
+            if (m_debugEnabled) 
+                m_log.DebugFormat(
+                    "[GROUPS]: {0} called with groupID={1}, agentID={2}",
+                    System.Reflection.MethodBase.GetCurrentMethod().Name, groupID, agentID);
+
+            return m_groupData.GetAgentGroupMembership(UUID.Zero, agentID, groupID);
+        }
+
+        public void UpdateGroupInfo(IClientAPI remoteClient, UUID groupID, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // Note: Permissions checking for modification rights is handled by the Groups Server/Service
+            m_groupData.UpdateGroup(GetRequestingAgentID(remoteClient), groupID, charter, showInList, insigniaID, membershipFee, openEnrollment, allowPublish, maturePublish);
+        }
+
+        public void SetGroupAcceptNotices(IClientAPI remoteClient, UUID groupID, bool acceptNotices, bool listInProfile)
+        {
+            // Note: Permissions checking for modification rights is handled by the Groups Server/Service
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            m_groupData.SetAgentGroupInfo(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID, acceptNotices, listInProfile);
+        }
+
+        public UUID CreateGroup(IClientAPI remoteClient, string name, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            if (m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), UUID.Zero, name) != null)
+            {
+                remoteClient.SendCreateGroupReply(UUID.Zero, false, "A group with the same name already exists.");
+                return UUID.Zero;
+            }
+
+            // check user level
+            ScenePresence avatar = null;
+            Scene scene = (Scene)remoteClient.Scene;
+            scene.TryGetScenePresence(remoteClient.AgentId, out avatar);
+
+            if (avatar != null)
+            {
+                if (avatar.UserLevel < m_levelGroupCreate)
+                {
+                    remoteClient.SendCreateGroupReply(UUID.Zero, false, "You have got insufficient permissions to create a group.");
+                    return UUID.Zero;
+                }
+            }
+
+            // check funds
+            // is there is a money module present ?
+            IMoneyModule money = scene.RequestModuleInterface<IMoneyModule>();
+            if (money != null)
+            {
+                // do the transaction, that is if the agent has got sufficient funds
+                if (!money.AmountCovered(remoteClient.AgentId, money.GroupCreationCharge)) {
+                    remoteClient.SendCreateGroupReply(UUID.Zero, false, "You have got insufficient funds to create a group.");
+                    return UUID.Zero;
+                }
+                money.ApplyCharge(GetRequestingAgentID(remoteClient), money.GroupCreationCharge, MoneyTransactionType.GroupCreate);
+            }
+            UUID groupID = m_groupData.CreateGroup(GetRequestingAgentID(remoteClient), name, charter, showInList, insigniaID, membershipFee, openEnrollment, allowPublish, maturePublish, GetRequestingAgentID(remoteClient));
+
+            remoteClient.SendCreateGroupReply(groupID, true, "Group created successfullly");
+
+            // Update the founder with new group information.
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
+
+            return groupID;
+        }
+
+        public GroupNoticeData[] GroupNoticesListRequest(IClientAPI remoteClient, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // ToDo: check if agent is a member of group and is allowed to see notices?
+
+            return m_groupData.GetGroupNotices(GetRequestingAgentID(remoteClient), groupID).ToArray();
+        }
+
+        /// <summary>
+        /// Get the title of the agent's current role.
+        /// </summary>
+        public string GetGroupTitle(UUID avatarID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            GroupMembershipData membership = m_groupData.GetAgentActiveMembership(UUID.Zero, avatarID);
+            if (membership != null)
+            {
+                return membership.GroupTitle;
+            } 
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Change the current Active Group Role for Agent
+        /// </summary>
+        public void GroupTitleUpdate(IClientAPI remoteClient, UUID groupID, UUID titleRoleID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            m_groupData.SetAgentActiveGroupRole(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID, titleRoleID);
+
+            // TODO: Not sure what all is needed here, but if the active group role change is for the group
+            // the client currently has set active, then we need to do a scene presence update too
+            // if (m_groupData.GetAgentActiveMembership(GetRequestingAgentID(remoteClient)).GroupID == GroupID)
+                
+            UpdateAllClientsWithGroupInfo(GetRequestingAgentID(remoteClient));
+        }
+
+
+        public void GroupRoleUpdate(IClientAPI remoteClient, UUID groupID, UUID roleID, string name, string description, string title, ulong powers, byte updateType)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // Security Checks are handled in the Groups Service.
+
+            switch ((OpenMetaverse.GroupRoleUpdate)updateType)
+            {
+                case OpenMetaverse.GroupRoleUpdate.Create:
+                    m_groupData.AddGroupRole(GetRequestingAgentID(remoteClient), groupID, UUID.Random(), name, description, title, powers);
+                    break;
+
+                case OpenMetaverse.GroupRoleUpdate.Delete:
+                    m_groupData.RemoveGroupRole(GetRequestingAgentID(remoteClient), groupID, roleID);
+                    break;
+
+                case OpenMetaverse.GroupRoleUpdate.UpdateAll:
+                case OpenMetaverse.GroupRoleUpdate.UpdateData:
+                case OpenMetaverse.GroupRoleUpdate.UpdatePowers:
+                    if (m_debugEnabled)
+                    {
+                        GroupPowers gp = (GroupPowers)powers;
+                        m_log.DebugFormat("[GROUPS]: Role ({0}) updated with Powers ({1}) ({2})", name, powers.ToString(), gp.ToString());
+                    }
+                    m_groupData.UpdateGroupRole(GetRequestingAgentID(remoteClient), groupID, roleID, name, description, title, powers);
+                    break;
+
+                case OpenMetaverse.GroupRoleUpdate.NoUpdate:
+                default:
+                    // No Op
+                    break;
+
+            }
+
+            // TODO: This update really should send out updates for everyone in the role that just got changed.
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
+        }
+
+        public void GroupRoleChanges(IClientAPI remoteClient, UUID groupID, UUID roleID, UUID memberID, uint changes)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+            // Todo: Security check
+
+            switch (changes)
+            {
+                case 0:
+                    // Add
+                    m_groupData.AddAgentToGroupRole(GetRequestingAgentID(remoteClient), memberID, groupID, roleID);
+
+                    break;
+                case 1:
+                    // Remove
+                    m_groupData.RemoveAgentFromGroupRole(GetRequestingAgentID(remoteClient), memberID, groupID, roleID);
+                    
+                    break;
+                default:
+                    m_log.ErrorFormat("[GROUPS]: {0} does not understand changes == {1}", System.Reflection.MethodBase.GetCurrentMethod().Name, changes);
+                    break;
+            }
+
+            // TODO: This update really should send out updates for everyone in the role that just got changed.
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
+        }
+
+        public void GroupNoticeRequest(IClientAPI remoteClient, UUID groupNoticeID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            GroupNoticeInfo data = m_groupData.GetGroupNotice(GetRequestingAgentID(remoteClient), groupNoticeID);
+
+            if (data != null)
+            {
+                GridInstantMessage msg = CreateGroupNoticeIM(remoteClient.AgentId, groupNoticeID, (byte)InstantMessageDialog.GroupNoticeRequested);
+
+                OutgoingInstantMessage(msg, GetRequestingAgentID(remoteClient));
+            }
+        }
+
+        public GridInstantMessage CreateGroupNoticeIM(UUID agentID, UUID groupNoticeID, byte dialog)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            GridInstantMessage msg = new GridInstantMessage();
+            byte[] bucket;
+
+            msg.imSessionID = groupNoticeID.Guid;
+            msg.toAgentID = agentID.Guid;
+            msg.dialog = dialog;
+            msg.fromGroup = true;
+            msg.offline = (byte)0;
+            msg.ParentEstateID = 0;
+            msg.Position = Vector3.Zero;
+            msg.RegionID = UUID.Zero.Guid;
+
+            GroupNoticeInfo info = m_groupData.GetGroupNotice(agentID, groupNoticeID);
+            if (info != null)
+            {
+                msg.fromAgentID = info.GroupID.Guid;
+                msg.timestamp = info.noticeData.Timestamp;
+                msg.fromAgentName = info.noticeData.FromName;
+                msg.message = info.noticeData.Subject + "|" + info.Message;
+
+                if (info.BinaryBucket[0] > 0)
+                {
+                    //32 is due to not needing space for two of the UUIDs.
+                    //(Don't need UUID of attachment or its owner in IM)
+                    //50 offset gets us to start of attachment name.
+                    //We are skipping the attachment flag, type, and
+                    //the three UUID fields at the start of the bucket.
+                    bucket = new byte[info.BinaryBucket.Length-32];
+                    bucket[0] = 1;      //Has attachment
+                    bucket[1] = info.BinaryBucket[1];
+                    Array.Copy(info.BinaryBucket, 50,
+                               bucket, 18, info.BinaryBucket.Length-50);
+                }
+                else
+                {
+                    bucket = new byte[19];
+                    bucket[0] = 0;      //No attachment
+                    bucket[1] = 0;      //Attachment type
+                    bucket[18] = 0;     //NUL terminate name
+                }
+
+                info.GroupID.ToBytes(bucket, 2);
+                msg.binaryBucket = bucket;
+            }
+            else
+            {
+                if (m_debugEnabled)
+                    m_log.DebugFormat("[GROUPS]: Group Notice {0} not found, composing empty message.", groupNoticeID);
+
+                msg.fromAgentID = UUID.Zero.Guid;
+                msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
+                msg.fromAgentName = string.Empty;
+                msg.message = string.Empty;
+                msg.binaryBucket = new byte[0];
+            }
+
+            return msg;
+        }
+
+        public void SendAgentGroupDataUpdate(IClientAPI remoteClient)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // Send agent information about his groups
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
+        }
+
+        public void JoinGroupRequest(IClientAPI remoteClient, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // Should check to see if OpenEnrollment, or if there's an outstanding invitation
+            m_groupData.AddAgentToGroup(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID, UUID.Zero);
+
+            remoteClient.SendJoinGroupReply(groupID, true);
+
+            // Should this send updates to everyone in the group?
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
+        }
+
+        public void LeaveGroupRequest(IClientAPI remoteClient, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            m_groupData.RemoveAgentFromGroup(GetRequestingAgentID(remoteClient), GetRequestingAgentID(remoteClient), groupID);
+
+            remoteClient.SendLeaveGroupReply(groupID, true);
+
+            remoteClient.SendAgentDropGroup(groupID);
+
+            // SL sends out notifcations to the group messaging session that the person has left
+            // Should this also update everyone who is in the group?
+            SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
+        }
+
+        public void EjectGroupMemberRequest(IClientAPI remoteClient, UUID groupID, UUID ejecteeID)
+        {
+            EjectGroupMember(remoteClient, GetRequestingAgentID(remoteClient), groupID, ejecteeID);
+        }
+
+        public void EjectGroupMember(IClientAPI remoteClient, UUID agentID, UUID groupID, UUID ejecteeID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // Todo: Security check?
+            m_groupData.RemoveAgentFromGroup(agentID, ejecteeID, groupID);
+
+            string agentName;
+            RegionInfo regionInfo;
+
+            // remoteClient provided or just agentID?
+            if (remoteClient != null)
+            {
+                agentName = remoteClient.Name;
+                regionInfo = remoteClient.Scene.RegionInfo;
+                remoteClient.SendEjectGroupMemberReply(agentID, groupID, true);
+            }
+            else
+            {
+                IClientAPI client = GetActiveClient(agentID);
+
+                if (client != null)
+                {
+                    agentName = client.Name;
+                    regionInfo = client.Scene.RegionInfo;
+                    client.SendEjectGroupMemberReply(agentID, groupID, true);
+                }
+                else
+                {
+                    regionInfo = m_sceneList[0].RegionInfo;
+                    UserAccount acc = m_sceneList[0].UserAccountService.GetUserAccount(regionInfo.ScopeID, agentID);
+
+                    if (acc != null)
+                    {
+                        agentName = acc.FirstName + " " + acc.LastName;
+                    }
+                    else
+                    {
+                        agentName = "Unknown member";
+                    }
+                }
+            }
+
+            GroupRecord groupInfo = m_groupData.GetGroupRecord(agentID, groupID, null);
+
+            UserAccount account = m_sceneList[0].UserAccountService.GetUserAccount(regionInfo.ScopeID, ejecteeID);
+            if ((groupInfo == null) || (account == null))
+            {
+                return;
+            }
+
+            // Send Message to Ejectee
+            GridInstantMessage msg = new GridInstantMessage();
+            
+            msg.imSessionID = UUID.Zero.Guid;
+            msg.fromAgentID = agentID.Guid;
+            // msg.fromAgentID = info.GroupID;
+            msg.toAgentID = ejecteeID.Guid;
+            //msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
+            msg.timestamp = 0;
+            msg.fromAgentName = agentName;
+            msg.message = string.Format("You have been ejected from '{1}' by {0}.", agentName, groupInfo.GroupName);
+            msg.dialog = (byte)OpenMetaverse.InstantMessageDialog.MessageFromAgent;
+            msg.fromGroup = false;
+            msg.offline = (byte)0;
+            msg.ParentEstateID = 0;
+            msg.Position = Vector3.Zero;
+            msg.RegionID = regionInfo.RegionID.Guid;
+            msg.binaryBucket = new byte[0];
+            OutgoingInstantMessage(msg, ejecteeID);
+
+            // Message to ejector
+            // Interop, received special 210 code for ejecting a group member
+            // this only works within the comms servers domain, and won't work hypergrid
+            // TODO:FIXME: Use a presence server of some kind to find out where the
+            // client actually is, and try contacting that region directly to notify them,
+            // or provide the notification via xmlrpc update queue
+
+            msg = new GridInstantMessage();
+            msg.imSessionID = UUID.Zero.Guid;
+            msg.fromAgentID = agentID.Guid;
+            msg.toAgentID = agentID.Guid;
+            msg.timestamp = 0;
+            msg.fromAgentName = agentName;
+            if (account != null)
+            {
+                msg.message = string.Format("{2} has been ejected from '{1}' by {0}.", agentName, groupInfo.GroupName, account.FirstName + " " + account.LastName);
+            }
+            else
+            {
+                msg.message = string.Format("{2} has been ejected from '{1}' by {0}.", agentName, groupInfo.GroupName, "Unknown member");
+            }
+            msg.dialog = (byte)210; //interop
+            msg.fromGroup = false;
+            msg.offline = (byte)0;
+            msg.ParentEstateID = 0;
+            msg.Position = Vector3.Zero;
+            msg.RegionID = regionInfo.RegionID.Guid;
+            msg.binaryBucket = new byte[0];
+            OutgoingInstantMessage(msg, agentID);
+
+
+            // SL sends out messages to everyone in the group
+            // Who all should receive updates and what should they be updated with?
+            UpdateAllClientsWithGroupInfo(ejecteeID);
+        }
+
+        public void InviteGroupRequest(IClientAPI remoteClient, UUID groupID, UUID invitedAgentID, UUID roleID)
+        {
+            InviteGroup(remoteClient, GetRequestingAgentID(remoteClient), groupID, invitedAgentID, roleID);
+        }
+
+        public void InviteGroup(IClientAPI remoteClient, UUID agentID, UUID groupID, UUID invitedAgentID, UUID roleID)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            string agentName;
+            RegionInfo regionInfo;
+
+            // remoteClient provided or just agentID?
+            if (remoteClient != null)
+            {
+                agentName = remoteClient.Name;
+                regionInfo = remoteClient.Scene.RegionInfo;
+            }
+            else
+            {
+                IClientAPI client = GetActiveClient(agentID);
+
+                if (client != null)
+                {
+                    agentName = client.Name;
+                    regionInfo = client.Scene.RegionInfo;
+                }
+                else
+                {
+                    regionInfo = m_sceneList[0].RegionInfo;
+                    UserAccount account = m_sceneList[0].UserAccountService.GetUserAccount(regionInfo.ScopeID, agentID);
+
+                    if (account != null)
+                    {
+                        agentName = account.FirstName + " " + account.LastName;
+                    }
+                    else
+                    {
+                        agentName = "Unknown member";
+                    }
+                }
+            }
+
+            // Todo: Security check, probably also want to send some kind of notification
+            UUID InviteID = UUID.Random();
+
+            m_groupData.AddAgentToGroupInvite(agentID, InviteID, groupID, roleID, invitedAgentID);
+
+            // Check to see if the invite went through, if it did not then it's possible
+            // the remoteClient did not validate or did not have permission to invite.
+            GroupInviteInfo inviteInfo = m_groupData.GetAgentToGroupInvite(agentID, InviteID);
+
+            if (inviteInfo != null)
+            {
+                if (m_msgTransferModule != null)
+                {
+                    Guid inviteUUID = InviteID.Guid;
+
+                    GridInstantMessage msg = new GridInstantMessage();
+
+                    msg.imSessionID = inviteUUID;
+
+                    // msg.fromAgentID = agentID.Guid;
+                    msg.fromAgentID = groupID.Guid;
+                    msg.toAgentID = invitedAgentID.Guid;
+                    //msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
+                    msg.timestamp = 0;
+                    msg.fromAgentName = agentName;
+                    msg.message = string.Format("{0} has invited you to join a group. There is no cost to join this group.", agentName);
+                    msg.dialog = (byte)OpenMetaverse.InstantMessageDialog.GroupInvitation;
+                    msg.fromGroup = true;
+                    msg.offline = (byte)0;
+                    msg.ParentEstateID = 0;
+                    msg.Position = Vector3.Zero;
+                    msg.RegionID = regionInfo.RegionID.Guid;
+                    msg.binaryBucket = new byte[20];
+
+                    OutgoingInstantMessage(msg, invitedAgentID);
+                }
+            }
+        }
+
+        public List<DirGroupsReplyData> FindGroups(IClientAPI remoteClient, string query)
+        {
+            return m_groupData.FindGroups(GetRequestingAgentID(remoteClient), query);
+        }
+
+
+        #endregion
+
+        #region Client/Update Tools
+
+        /// <summary>
+        /// Try to find an active IClientAPI reference for agentID giving preference to root connections
+        /// </summary>
+        private IClientAPI GetActiveClient(UUID agentID)
+        {
+            IClientAPI child = null;
+
+            // Try root avatar first
+            foreach (Scene scene in m_sceneList)
+            {
+                ScenePresence sp = scene.GetScenePresence(agentID);
+                if (sp != null)
+                {
+                    if (!sp.IsChildAgent)
+                    {
+                        return sp.ControllingClient;
+                    }
+                    else
+                    {
+                        child = sp.ControllingClient;
+                    }
+                }
+            }
+
+            // If we didn't find a root, then just return whichever child we found, or null if none
+            return child;
+        }
+
+        /// <summary>
+        /// Send 'remoteClient' the group membership 'data' for agent 'dataForAgentID'.
+        /// </summary>
+        private void SendGroupMembershipInfoViaCaps(IClientAPI remoteClient, UUID dataForAgentID, GroupMembershipData[] data)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDArray AgentData = new OSDArray(1);
+            OSDMap AgentDataMap = new OSDMap(1);
+            AgentDataMap.Add("AgentID", OSD.FromUUID(dataForAgentID));
+            AgentData.Add(AgentDataMap);
+
+            OSDArray GroupData = new OSDArray(data.Length);
+            OSDArray NewGroupData = new OSDArray(data.Length);
+
+            foreach (GroupMembershipData membership in data)
+            {
+                if (GetRequestingAgentID(remoteClient) != dataForAgentID)
+                {
+                    if (!membership.ListInProfile)
+                    {
+                        // If we're sending group info to remoteclient about another agent, 
+                        // filter out groups the other agent doesn't want to share.
+                        continue;
+                    }
+                }
+
+                OSDMap GroupDataMap = new OSDMap(6);
+                OSDMap NewGroupDataMap = new OSDMap(1);
+
+                GroupDataMap.Add("GroupID", OSD.FromUUID(membership.GroupID));
+                GroupDataMap.Add("GroupPowers", OSD.FromULong(membership.GroupPowers));
+                GroupDataMap.Add("AcceptNotices", OSD.FromBoolean(membership.AcceptNotices));
+                GroupDataMap.Add("GroupInsigniaID", OSD.FromUUID(membership.GroupPicture));
+                GroupDataMap.Add("Contribution", OSD.FromInteger(membership.Contribution));
+                GroupDataMap.Add("GroupName", OSD.FromString(membership.GroupName));
+                NewGroupDataMap.Add("ListInProfile", OSD.FromBoolean(membership.ListInProfile));
+
+                GroupData.Add(GroupDataMap);
+                NewGroupData.Add(NewGroupDataMap);
+            }
+
+            OSDMap llDataStruct = new OSDMap(3);
+            llDataStruct.Add("AgentData", AgentData);
+            llDataStruct.Add("GroupData", GroupData);
+            llDataStruct.Add("NewGroupData", NewGroupData);
+
+            if (m_debugEnabled)
+            {
+                m_log.InfoFormat("[GROUPS]: {0}", OSDParser.SerializeJsonString(llDataStruct));
+            }
+
+            IEventQueue queue = remoteClient.Scene.RequestModuleInterface<IEventQueue>();
+
+            if (queue != null)
+            {
+                queue.Enqueue(queue.BuildEvent("AgentGroupDataUpdate", llDataStruct), GetRequestingAgentID(remoteClient));
+            }
+            
+        }
+
+        private void SendScenePresenceUpdate(UUID AgentID, string Title)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Updating scene title for {0} with title: {1}", AgentID, Title);
+
+            ScenePresence presence = null;
+
+            foreach (Scene scene in m_sceneList)
+            {
+                presence = scene.GetScenePresence(AgentID);
+                if (presence != null)
+                {
+                    if (presence.Grouptitle != Title)
+                    {
+                        presence.Grouptitle = Title;
+
+                        if (! presence.IsChildAgent)
+                            presence.SendAvatarDataToAllClients();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Send updates to all clients who might be interested in groups data for dataForClientID
+        /// </summary>
+        private void UpdateAllClientsWithGroupInfo(UUID dataForClientID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // TODO: Probably isn't nessesary to update every client in every scene.
+            // Need to examine client updates and do only what's nessesary.
+            lock (m_sceneList)
+            {
+                foreach (Scene scene in m_sceneList)
+                {
+                    scene.ForEachClient(delegate(IClientAPI client) { SendAgentGroupDataUpdate(client, dataForClientID); });
+                }
+            }
+        }
+
+        /// <summary>
+        /// Update remoteClient with group information about dataForAgentID
+        /// </summary>
+        private void SendAgentGroupDataUpdate(IClientAPI remoteClient, UUID dataForAgentID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called for {1}", System.Reflection.MethodBase.GetCurrentMethod().Name, remoteClient.Name);
+
+            // TODO: All the client update functions need to be reexamined because most do too much and send too much stuff
+
+            OnAgentDataUpdateRequest(remoteClient, dataForAgentID, UUID.Zero);
+
+            // Need to send a group membership update to the client
+            // UDP version doesn't seem to behave nicely.  But we're going to send it out here
+            // with an empty group membership to hopefully remove groups being displayed due
+            // to the core Groups Stub
+            remoteClient.SendGroupMembership(new GroupMembershipData[0]);
+
+            GroupMembershipData[] membershipArray = GetProfileListedGroupMemberships(remoteClient, dataForAgentID);
+            SendGroupMembershipInfoViaCaps(remoteClient, dataForAgentID, membershipArray);
+            remoteClient.SendAvatarGroupsReply(dataForAgentID, membershipArray);
+
+            if (remoteClient.AgentId == dataForAgentID)
+                remoteClient.RefreshGroupMembership();
+        }
+
+        /// <summary>
+        /// Get a list of groups memberships for the agent that are marked "ListInProfile"
+        /// (unless that agent has a godLike aspect, in which case get all groups)
+        /// </summary>
+        /// <param name="dataForAgentID"></param>
+        /// <returns></returns>
+        private GroupMembershipData[] GetProfileListedGroupMemberships(IClientAPI requestingClient, UUID dataForAgentID)
+        {
+            List<GroupMembershipData> membershipData = m_groupData.GetAgentGroupMemberships(requestingClient.AgentId, dataForAgentID);
+            GroupMembershipData[] membershipArray;
+
+            //  cScene and property accessor 'isGod' are in support of the opertions to bypass 'hidden' group attributes for
+            // those with a GodLike aspect.
+            Scene cScene = (Scene)requestingClient.Scene;
+            bool isGod = cScene.Permissions.IsGod(requestingClient.AgentId);
+
+            if (isGod)
+            {
+                membershipArray = membershipData.ToArray();
+            }
+            else
+            {
+                if (requestingClient.AgentId != dataForAgentID)
+                {
+                    Predicate<GroupMembershipData> showInProfile = delegate(GroupMembershipData membership)
+                    {
+                        return membership.ListInProfile;
+                    };
+
+                    membershipArray = membershipData.FindAll(showInProfile).ToArray();
+                }
+                else
+                {
+                    membershipArray = membershipData.ToArray();
+                }
+            }
+            
+            if (m_debugEnabled)
+            {
+                m_log.InfoFormat("[GROUPS]: Get group membership information for {0} requested by {1}", dataForAgentID, requestingClient.AgentId);
+                foreach (GroupMembershipData membership in membershipArray)
+                {
+                    m_log.InfoFormat("[GROUPS]: {0} :: {1} - {2} - {3}", dataForAgentID, membership.GroupName, membership.GroupTitle, membership.GroupPowers);
+                }
+            }
+
+            return membershipArray;
+        }
+
+ 
+        private void SendAgentDataUpdate(IClientAPI remoteClient, UUID dataForAgentID, UUID activeGroupID, string activeGroupName, ulong activeGroupPowers, string activeGroupTitle)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // TODO: All the client update functions need to be reexamined because most do too much and send too much stuff
+            UserAccount account = m_sceneList[0].UserAccountService.GetUserAccount(remoteClient.Scene.RegionInfo.ScopeID, dataForAgentID);
+            string firstname, lastname;
+            if (account != null)
+            {
+                firstname = account.FirstName;
+                lastname = account.LastName;
+            }
+            else
+            {
+                firstname = "Unknown";
+                lastname = "Unknown";
+            }
+
+            remoteClient.SendAgentDataUpdate(dataForAgentID, activeGroupID, firstname,
+                    lastname, activeGroupPowers, activeGroupName,
+                    activeGroupTitle);
+        }
+
+        #endregion
+
+        #region IM Backed Processes
+
+        private void OutgoingInstantMessage(GridInstantMessage msg, UUID msgTo)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            IClientAPI localClient = GetActiveClient(msgTo);
+            if (localClient != null)
+            {
+                if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: MsgTo ({0}) is local, delivering directly", localClient.Name);
+                localClient.SendInstantMessage(msg);
+            }
+            else if (m_msgTransferModule != null)
+            {
+                if (m_debugEnabled) m_log.InfoFormat("[GROUPS]: MsgTo ({0}) is not local, delivering via TransferModule", msgTo);
+                m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { if (m_debugEnabled) m_log.DebugFormat("[GROUPS]: Message Sent: {0}", success?"Succeeded":"Failed"); });
+            }
+        }
+
+        public void NotifyChange(UUID groupID)
+        {
+            // Notify all group members of a chnge in group roles and/or
+            // permissions
+            //
+        }
+
+        #endregion
+
+        private UUID GetRequestingAgentID(IClientAPI client)
+        {
+            UUID requestingAgentID = UUID.Zero;
+            if (client != null)
+            {
+                requestingAgentID = client.AgentId;
+            }
+            return requestingAgentID;
+        }
+    }
+
+    public class GroupNoticeInfo
+    {
+        public GroupNoticeData noticeData = new GroupNoticeData();
+        public UUID GroupID = UUID.Zero;
+        public string Message = string.Empty;
+        public byte[] BinaryBucket = new byte[0];
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/IGroupsServicesConnector.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/IGroupsServicesConnector.cs
new file mode 100644
index 0000000..6b5b40a
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/IGroupsServicesConnector.cs
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
+{
+    public interface IGroupsServicesConnector
+    {
+        UUID CreateGroup(UUID RequestingAgentID, string name, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish, UUID founderID);
+        void UpdateGroup(UUID RequestingAgentID, UUID groupID, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, bool allowPublish, bool maturePublish);
+
+        /// <summary>
+        /// Get the group record.
+        /// </summary>
+        /// <returns></returns>
+        /// <param name='RequestingAgentID'>The UUID of the user making the request.</param>
+        /// <param name='GroupID'>
+        /// The ID of the record to retrieve.  
+        /// GroupName may be specified instead, in which case this parameter will be UUID.Zero
+        /// </param>
+        /// <param name='GroupName'>
+        /// The name of the group to retrieve.
+        /// GroupID may be specified instead, in which case this parmeter will be null.
+        /// </param>
+        GroupRecord GetGroupRecord(UUID RequestingAgentID, UUID GroupID, string GroupName);
+       
+        List<DirGroupsReplyData> FindGroups(UUID RequestingAgentID, string search);
+        List<GroupMembersData> GetGroupMembers(UUID RequestingAgentID, UUID GroupID);
+
+        void AddGroupRole(UUID RequestingAgentID, UUID groupID, UUID roleID, string name, string description, string title, ulong powers);
+        void UpdateGroupRole(UUID RequestingAgentID, UUID groupID, UUID roleID, string name, string description, string title, ulong powers);
+        void RemoveGroupRole(UUID RequestingAgentID, UUID groupID, UUID roleID);
+        List<GroupRolesData> GetGroupRoles(UUID RequestingAgentID, UUID GroupID);
+        List<GroupRoleMembersData> GetGroupRoleMembers(UUID RequestingAgentID, UUID GroupID);
+
+        void AddAgentToGroup(UUID RequestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID);
+        void RemoveAgentFromGroup(UUID RequestingAgentID, UUID AgentID, UUID GroupID);
+
+        void AddAgentToGroupInvite(UUID RequestingAgentID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID);
+        GroupInviteInfo GetAgentToGroupInvite(UUID RequestingAgentID, UUID inviteID);
+        void RemoveAgentToGroupInvite(UUID RequestingAgentID, UUID inviteID);
+
+        void AddAgentToGroupRole(UUID RequestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID);
+        void RemoveAgentFromGroupRole(UUID RequestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID);
+        List<GroupRolesData> GetAgentGroupRoles(UUID RequestingAgentID, UUID AgentID, UUID GroupID);
+
+        void SetAgentActiveGroup(UUID RequestingAgentID, UUID AgentID, UUID GroupID);
+        GroupMembershipData GetAgentActiveMembership(UUID RequestingAgentID, UUID AgentID);
+
+        void SetAgentActiveGroupRole(UUID RequestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID);
+        void SetAgentGroupInfo(UUID RequestingAgentID, UUID AgentID, UUID GroupID, bool AcceptNotices, bool ListInProfile);
+
+        /// <summary>
+        /// Get information about a specific group to which the user belongs.
+        /// </summary>
+        /// <param name="RequestingAgentID">The agent requesting the information.</param>
+        /// <param name="AgentID">The agent requested.</param>
+        /// <param name="GroupID">The group requested.</param>
+        /// <returns>
+        /// If the user is a member of the group then the data structure is returned.  If not, then null is returned.
+        /// </returns>
+        GroupMembershipData GetAgentGroupMembership(UUID RequestingAgentID, UUID AgentID, UUID GroupID);
+        
+        /// <summary>
+        /// Get information about the groups to which a user belongs.
+        /// </summary>
+        /// <param name="RequestingAgentID">The agent requesting the information.</param>
+        /// <param name="AgentID">The agent requested.</param>
+        /// <returns>
+        /// Information about the groups to which the user belongs.  If the user belongs to no groups then an empty
+        /// list is returned.
+        /// </returns>
+        List<GroupMembershipData> GetAgentGroupMemberships(UUID RequestingAgentID, UUID AgentID);
+
+        void AddGroupNotice(UUID RequestingAgentID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket);
+        GroupNoticeInfo GetGroupNotice(UUID RequestingAgentID, UUID noticeID);
+        List<GroupNoticeData> GetGroupNotices(UUID RequestingAgentID, UUID GroupID);
+
+        void ResetAgentGroupChatSessions(UUID agentID);
+        bool hasAgentBeenInvitedToGroupChatSession(UUID agentID, UUID groupID);
+        bool hasAgentDroppedGroupChatSession(UUID agentID, UUID groupID);
+        void AgentDroppedFromGroupChatSession(UUID agentID, UUID groupID);
+        void AgentInvitedToGroupChatSession(UUID agentID, UUID groupID);
+    }
+
+    public class GroupInviteInfo
+    {
+        public UUID GroupID  = UUID.Zero;
+        public UUID RoleID   = UUID.Zero;
+        public UUID AgentID  = UUID.Zero;
+        public UUID InviteID = UUID.Zero;
+    }
+}
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs
new file mode 100644
index 0000000..8095b28
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs
@@ -0,0 +1,1441 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.Threading;
+
+using Nwc.XmlRpc;
+
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+
+/***************************************************************************
+ * Simian Data Map
+ * ===============
+ * 
+ * OwnerID -> Type -> Key
+ * -----------------------
+ * 
+ * UserID -> Group -> ActiveGroup
+ * + GroupID
+ * 
+ * UserID -> GroupSessionDropped -> GroupID
+ * UserID -> GroupSessionInvited -> GroupID
+ * 
+ * UserID -> GroupMember -> GroupID
+ * + SelectedRoleID [UUID]
+ * + AcceptNotices  [bool]
+ * + ListInProfile  [bool]
+ * + Contribution   [int]
+ *
+ * UserID -> GroupRole[GroupID] -> RoleID
+ * 
+ * 
+ * GroupID -> Group -> GroupName 
+ * + Charter
+ * + ShowInList
+ * + InsigniaID
+ * + MembershipFee
+ * + OpenEnrollment
+ * + AllowPublish
+ * + MaturePublish
+ * + FounderID
+ * + EveryonePowers
+ * + OwnerRoleID
+ * + OwnersPowers
+ * 
+ * GroupID -> GroupRole -> RoleID
+ * + Name
+ * + Description
+ * + Title
+ * + Powers
+ * 
+ * GroupID -> GroupMemberInvite -> InviteID
+ * + AgentID
+ * + RoleID
+ * 
+ * GroupID -> GroupNotice -> NoticeID
+ * + TimeStamp      [uint]
+ * + FromName       [string]
+ * + Subject        [string]
+ * + Message        [string]
+ * + BinaryBucket   [byte[]]
+ *
+ * */
+
+namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "SimianGroupsServicesConnectorModule")]
+    public class SimianGroupsServicesConnectorModule : ISharedRegionModule, IGroupsServicesConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public const GroupPowers m_DefaultEveryonePowers = GroupPowers.AllowSetHome | 
+            GroupPowers.Accountable | 
+            GroupPowers.JoinChat | 
+            GroupPowers.AllowVoiceChat | 
+            GroupPowers.ReceiveNotices | 
+            GroupPowers.StartProposal | 
+            GroupPowers.VoteOnProposal;
+
+        // Would this be cleaner as (GroupPowers)ulong.MaxValue;
+        public const GroupPowers m_DefaultOwnerPowers = GroupPowers.Accountable
+                                | GroupPowers.AllowEditLand
+                                | GroupPowers.AllowFly
+                                | GroupPowers.AllowLandmark
+                                | GroupPowers.AllowRez
+                                | GroupPowers.AllowSetHome
+                                | GroupPowers.AllowVoiceChat
+                                | GroupPowers.AssignMember
+                                | GroupPowers.AssignMemberLimited
+                                | GroupPowers.ChangeActions
+                                | GroupPowers.ChangeIdentity
+                                | GroupPowers.ChangeMedia
+                                | GroupPowers.ChangeOptions
+                                | GroupPowers.CreateRole
+                                | GroupPowers.DeedObject
+                                | GroupPowers.DeleteRole
+                                | GroupPowers.Eject
+                                | GroupPowers.FindPlaces
+                                | GroupPowers.Invite
+                                | GroupPowers.JoinChat
+                                | GroupPowers.LandChangeIdentity
+                                | GroupPowers.LandDeed
+                                | GroupPowers.LandDivideJoin
+                                | GroupPowers.LandEdit
+                                | GroupPowers.LandEjectAndFreeze
+                                | GroupPowers.LandGardening
+                                | GroupPowers.LandManageAllowed
+                                | GroupPowers.LandManageBanned
+                                | GroupPowers.LandManagePasses
+                                | GroupPowers.LandOptions
+                                | GroupPowers.LandRelease
+                                | GroupPowers.LandSetSale
+                                | GroupPowers.ModerateChat
+                                | GroupPowers.ObjectManipulate
+                                | GroupPowers.ObjectSetForSale
+                                | GroupPowers.ReceiveNotices
+                                | GroupPowers.RemoveMember
+                                | GroupPowers.ReturnGroupOwned
+                                | GroupPowers.ReturnGroupSet
+                                | GroupPowers.ReturnNonGroup
+                                | GroupPowers.RoleProperties
+                                | GroupPowers.SendNotices
+                                | GroupPowers.SetLandingPoint
+                                | GroupPowers.StartProposal
+                                | GroupPowers.VoteOnProposal;
+
+        private bool m_connectorEnabled = false;
+
+        private string m_groupsServerURI = string.Empty;
+
+        private bool m_debugEnabled = false;
+
+        private Dictionary<string, bool> m_pendingRequests = new Dictionary<string,bool>();
+        
+        private ExpiringCache<string, OSDMap> m_memoryCache;
+        private int m_cacheTimeout = 30;
+
+        // private IUserAccountService m_accountService = null;
+        
+
+        #region Region Module interfaceBase Members
+
+        public string Name
+        {
+            get { return "SimianGroupsServicesConnector"; }
+        }
+
+        // this module is not intended to be replaced, but there should only be 1 of them.
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource config)
+        {
+            IConfig groupsConfig = config.Configs["Groups"];
+
+            if (groupsConfig == null)
+            {
+                // Do not run this module by default.
+                return;
+            }
+            else
+            {
+                // if groups aren't enabled, we're not needed.
+                // if we're not specified as the connector to use, then we're not wanted
+                if ((groupsConfig.GetBoolean("Enabled", false) == false)
+                    || (groupsConfig.GetString("ServicesConnectorModule", "XmlRpcGroupsServicesConnector") != Name))
+                {
+                    m_connectorEnabled = false;
+                    return;
+                }
+
+                m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]: Initializing {0}", this.Name);
+
+                m_groupsServerURI = groupsConfig.GetString("GroupsServerURI", string.Empty);
+                if (string.IsNullOrEmpty(m_groupsServerURI))
+                {
+                    m_log.ErrorFormat("Please specify a valid Simian Server for GroupsServerURI in OpenSim.ini, [Groups]");
+                    m_connectorEnabled = false;
+                    return;
+                }
+
+
+                m_cacheTimeout = groupsConfig.GetInt("GroupsCacheTimeout", 30);
+                if (m_cacheTimeout == 0)
+                {
+                    m_log.WarnFormat("[SIMIAN-GROUPS-CONNECTOR] Groups Cache Disabled.");
+                }
+                else
+                {
+                    m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR] Groups Cache Timeout set to {0}.", m_cacheTimeout);
+                }
+
+                
+
+                m_memoryCache = new ExpiringCache<string,OSDMap>();
+                
+
+                // If we got all the config options we need, lets start'er'up
+                m_connectorEnabled = true;
+
+                m_debugEnabled = groupsConfig.GetBoolean("DebugEnabled", true);
+
+            }
+        }
+
+        public void Close()
+        {
+            m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]: Closing {0}", this.Name);
+        }
+
+        public void AddRegion(OpenSim.Region.Framework.Scenes.Scene scene)
+        {
+            if (m_connectorEnabled)
+            {
+                scene.RegisterModuleInterface<IGroupsServicesConnector>(this);
+            }
+        }
+
+        public void RemoveRegion(OpenSim.Region.Framework.Scenes.Scene scene)
+        {
+            if (scene.RequestModuleInterface<IGroupsServicesConnector>() == this)
+            {
+                scene.UnregisterModuleInterface<IGroupsServicesConnector>(this);
+            }
+        }
+
+        public void RegionLoaded(OpenSim.Region.Framework.Scenes.Scene scene)
+        {
+            // TODO: May want to consider listenning for Agent Connections so we can pre-cache group info
+            // scene.EventManager.OnNewClient += OnNewClient;
+        }
+
+        #endregion
+
+        #region ISharedRegionModule Members
+
+        public void PostInitialise()
+        {
+            // NoOp
+        }
+
+        #endregion
+
+
+
+
+        #region IGroupsServicesConnector Members
+
+        /// <summary>
+        /// Create a Group, including Everyone and Owners Role, place FounderID in both groups, select Owner as selected role, and newly created group as agent's active role.
+        /// </summary>
+        public UUID CreateGroup(UUID requestingAgentID, string name, string charter, bool showInList, UUID insigniaID, 
+                                int membershipFee, bool openEnrollment, bool allowPublish, 
+                                bool maturePublish, UUID founderID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            UUID GroupID     = UUID.Random();
+            UUID OwnerRoleID = UUID.Random();
+
+            OSDMap GroupInfoMap = new OSDMap();
+            GroupInfoMap["Charter"] = OSD.FromString(charter);
+            GroupInfoMap["ShowInList"] = OSD.FromBoolean(showInList);
+            GroupInfoMap["InsigniaID"] = OSD.FromUUID(insigniaID);
+            GroupInfoMap["MembershipFee"] = OSD.FromInteger(0);
+            GroupInfoMap["OpenEnrollment"] = OSD.FromBoolean(openEnrollment);
+            GroupInfoMap["AllowPublish"] = OSD.FromBoolean(allowPublish);
+            GroupInfoMap["MaturePublish"] = OSD.FromBoolean(maturePublish);
+            GroupInfoMap["FounderID"] = OSD.FromUUID(founderID);
+            GroupInfoMap["EveryonePowers"] = OSD.FromULong((ulong)m_DefaultEveryonePowers);
+            GroupInfoMap["OwnerRoleID"] = OSD.FromUUID(OwnerRoleID);
+            GroupInfoMap["OwnersPowers"] = OSD.FromULong((ulong)m_DefaultOwnerPowers);
+
+            if (SimianAddGeneric(GroupID, "Group", name, GroupInfoMap))
+            {
+                AddGroupRole(requestingAgentID, GroupID, UUID.Zero, "Everyone", "Members of " + name, "Member of " + name, (ulong)m_DefaultEveryonePowers);
+                AddGroupRole(requestingAgentID, GroupID, OwnerRoleID, "Owners", "Owners of " + name, "Owner of " + name, (ulong)m_DefaultOwnerPowers);
+                
+                AddAgentToGroup(requestingAgentID, requestingAgentID, GroupID, OwnerRoleID);
+
+                return GroupID;
+            }
+            else
+            {
+                return UUID.Zero;
+            }
+        }
+
+
+        public void UpdateGroup(UUID requestingAgentID, UUID groupID, string charter, bool showInList, 
+                                UUID insigniaID, int membershipFee, bool openEnrollment, 
+                                bool allowPublish, bool maturePublish)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+            // TODO: Check to make sure requestingAgentID has permission to update group
+
+            string GroupName;
+            OSDMap GroupInfoMap;
+            if (SimianGetFirstGenericEntry(groupID, "GroupInfo", out GroupName, out GroupInfoMap))
+            {
+                GroupInfoMap["Charter"] = OSD.FromString(charter);
+                GroupInfoMap["ShowInList"] = OSD.FromBoolean(showInList);
+                GroupInfoMap["InsigniaID"] = OSD.FromUUID(insigniaID);
+                GroupInfoMap["MembershipFee"] = OSD.FromInteger(0);
+                GroupInfoMap["OpenEnrollment"] = OSD.FromBoolean(openEnrollment);
+                GroupInfoMap["AllowPublish"] = OSD.FromBoolean(allowPublish);
+                GroupInfoMap["MaturePublish"] = OSD.FromBoolean(maturePublish);
+
+                SimianAddGeneric(groupID, "Group", GroupName, GroupInfoMap);
+            }
+
+        }
+
+
+        public void AddGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID, string name, string description, 
+                                 string title, ulong powers)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap GroupRoleInfo = new OSDMap();
+            GroupRoleInfo["Name"] = OSD.FromString(name);
+            GroupRoleInfo["Description"] = OSD.FromString(description);
+            GroupRoleInfo["Title"] = OSD.FromString(title);
+            GroupRoleInfo["Powers"] = OSD.FromULong((ulong)powers);
+
+            // TODO: Add security, make sure that requestingAgentID has permision to add roles
+            SimianAddGeneric(groupID, "GroupRole", roleID.ToString(), GroupRoleInfo);
+        }
+
+        public void RemoveGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // TODO: Add security
+
+            // Can't delete the Everyone Role
+            if (roleID != UUID.Zero)
+            {
+                // Remove all GroupRole Members from Role
+                Dictionary<UUID, OSDMap> GroupRoleMembers;
+                string GroupRoleMemberType = "GroupRole" + groupID.ToString();
+                if (SimianGetGenericEntries(GroupRoleMemberType, roleID.ToString(), out GroupRoleMembers))
+                {
+                    foreach (UUID UserID in GroupRoleMembers.Keys)
+                    {
+                        EnsureRoleNotSelectedByMember(groupID, roleID, UserID);
+
+                        SimianRemoveGenericEntry(UserID, GroupRoleMemberType, roleID.ToString());
+                    }
+                }
+
+                // Remove role
+                SimianRemoveGenericEntry(groupID, "GroupRole", roleID.ToString());
+            }
+        }
+
+
+        public void UpdateGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID, string name, string description, 
+                                    string title, ulong powers)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // TODO: Security, check that requestingAgentID is allowed to update group roles
+
+            OSDMap GroupRoleInfo;
+            if (SimianGetGenericEntry(groupID, "GroupRole", roleID.ToString(), out GroupRoleInfo))
+            {
+                if (name != null)
+                {
+                    GroupRoleInfo["Name"] = OSD.FromString(name);
+                }
+                if (description != null)
+                {
+                    GroupRoleInfo["Description"] = OSD.FromString(description);
+                }
+                if (title != null)
+                {
+                    GroupRoleInfo["Title"] = OSD.FromString(title);
+                }
+                GroupRoleInfo["Powers"] = OSD.FromULong((ulong)powers);
+
+            }
+
+
+            SimianAddGeneric(groupID, "GroupRole", roleID.ToString(), GroupRoleInfo);
+        }
+
+        public GroupRecord GetGroupRecord(UUID requestingAgentID, UUID groupID, string groupName)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap GroupInfoMap = null;
+            if (groupID != UUID.Zero)
+            {
+                if (!SimianGetFirstGenericEntry(groupID, "Group", out groupName, out GroupInfoMap))
+                {
+                    return null;
+                }
+            } 
+            else if (!string.IsNullOrEmpty(groupName))
+            {
+                if (!SimianGetFirstGenericEntry("Group", groupName, out groupID, out GroupInfoMap))
+                {
+                    return null;
+                }
+            }
+
+            GroupRecord GroupInfo = new GroupRecord();
+
+            GroupInfo.GroupID = groupID;
+            GroupInfo.GroupName = groupName;
+            GroupInfo.Charter = GroupInfoMap["Charter"].AsString();
+            GroupInfo.ShowInList = GroupInfoMap["ShowInList"].AsBoolean();
+            GroupInfo.GroupPicture = GroupInfoMap["InsigniaID"].AsUUID();
+            GroupInfo.MembershipFee = GroupInfoMap["MembershipFee"].AsInteger();
+            GroupInfo.OpenEnrollment = GroupInfoMap["OpenEnrollment"].AsBoolean();
+            GroupInfo.AllowPublish = GroupInfoMap["AllowPublish"].AsBoolean();
+            GroupInfo.MaturePublish = GroupInfoMap["MaturePublish"].AsBoolean();
+            GroupInfo.FounderID = GroupInfoMap["FounderID"].AsUUID();
+            GroupInfo.OwnerRoleID = GroupInfoMap["OwnerRoleID"].AsUUID();
+
+            return GroupInfo;
+
+        }
+
+        public GroupProfileData GetMemberGroupProfile(UUID requestingAgentID, UUID groupID, UUID memberID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap groupProfile;
+            string groupName;
+            if (!SimianGetFirstGenericEntry(groupID, "Group", out groupName, out groupProfile))
+            {
+                // GroupProfileData is not nullable
+                return new GroupProfileData();
+            }
+
+            GroupProfileData MemberGroupProfile = new GroupProfileData();
+            MemberGroupProfile.GroupID = groupID;
+            MemberGroupProfile.Name = groupName;
+
+            if (groupProfile["Charter"] != null)
+            {
+                MemberGroupProfile.Charter = groupProfile["Charter"].AsString();
+            }
+            
+            MemberGroupProfile.ShowInList = groupProfile["ShowInList"].AsString() == "1";
+            MemberGroupProfile.InsigniaID = groupProfile["InsigniaID"].AsUUID();
+            MemberGroupProfile.MembershipFee = groupProfile["MembershipFee"].AsInteger();
+            MemberGroupProfile.OpenEnrollment = groupProfile["OpenEnrollment"].AsBoolean();
+            MemberGroupProfile.AllowPublish = groupProfile["AllowPublish"].AsBoolean();
+            MemberGroupProfile.MaturePublish = groupProfile["MaturePublish"].AsBoolean();
+            MemberGroupProfile.FounderID = groupProfile["FounderID"].AsUUID();;
+            MemberGroupProfile.OwnerRole = groupProfile["OwnerRoleID"].AsUUID(); 
+
+            Dictionary<UUID, OSDMap> Members;
+            if (SimianGetGenericEntries("GroupMember",groupID.ToString(), out Members))
+            {
+                MemberGroupProfile.GroupMembershipCount = Members.Count;
+            }
+
+            Dictionary<string, OSDMap> Roles;
+            if (SimianGetGenericEntries(groupID, "GroupRole", out Roles))
+            {
+                MemberGroupProfile.GroupRolesCount = Roles.Count;
+            }
+
+            // TODO: Get Group Money balance from somewhere
+            // group.Money = 0;
+
+            GroupMembershipData MemberInfo = GetAgentGroupMembership(requestingAgentID, memberID, groupID);
+
+            MemberGroupProfile.MemberTitle = MemberInfo.GroupTitle;
+            MemberGroupProfile.PowersMask = MemberInfo.GroupPowers;
+
+            return MemberGroupProfile;
+        }
+
+        public void SetAgentActiveGroup(UUID requestingAgentID, UUID agentID, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap ActiveGroup = new OSDMap();
+            ActiveGroup.Add("GroupID", OSD.FromUUID(groupID));
+            SimianAddGeneric(agentID, "Group", "ActiveGroup", ActiveGroup);
+        }
+
+        public void SetAgentActiveGroupRole(UUID requestingAgentID, UUID agentID, UUID groupID, UUID roleID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap GroupMemberInfo;
+            if (!SimianGetGenericEntry(agentID, "GroupMember", groupID.ToString(), out GroupMemberInfo))
+            {
+                GroupMemberInfo = new OSDMap();
+            }
+
+            GroupMemberInfo["SelectedRoleID"] = OSD.FromUUID(roleID);
+            SimianAddGeneric(agentID, "GroupMember", groupID.ToString(), GroupMemberInfo);
+        }
+
+        public void SetAgentGroupInfo(UUID requestingAgentID, UUID agentID, UUID groupID, bool acceptNotices, bool listInProfile)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap GroupMemberInfo;
+            if (!SimianGetGenericEntry(agentID, "GroupMember", groupID.ToString(), out GroupMemberInfo))
+            {
+                GroupMemberInfo = new OSDMap();
+            }
+            
+            GroupMemberInfo["AcceptNotices"] = OSD.FromBoolean(acceptNotices);
+            GroupMemberInfo["ListInProfile"] = OSD.FromBoolean(listInProfile);
+            GroupMemberInfo["Contribution"] = OSD.FromInteger(0);
+            GroupMemberInfo["SelectedRole"] = OSD.FromUUID(UUID.Zero);
+            SimianAddGeneric(agentID, "GroupMember", groupID.ToString(), GroupMemberInfo);
+        }
+
+        public void AddAgentToGroupInvite(UUID requestingAgentID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap Invite = new OSDMap();
+            Invite["AgentID"] = OSD.FromUUID(agentID);
+            Invite["RoleID"] = OSD.FromUUID(roleID);
+
+            SimianAddGeneric(groupID, "GroupMemberInvite", inviteID.ToString(), Invite);
+        }
+
+        public GroupInviteInfo GetAgentToGroupInvite(UUID requestingAgentID, UUID inviteID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap GroupMemberInvite;
+            UUID GroupID;
+            if (!SimianGetFirstGenericEntry("GroupMemberInvite", inviteID.ToString(), out GroupID, out GroupMemberInvite))
+            {
+                return null;
+            }
+
+            GroupInviteInfo inviteInfo = new GroupInviteInfo();
+            inviteInfo.InviteID = inviteID;
+            inviteInfo.GroupID = GroupID;
+            inviteInfo.AgentID = GroupMemberInvite["AgentID"].AsUUID();
+            inviteInfo.RoleID = GroupMemberInvite["RoleID"].AsUUID();
+
+            return inviteInfo;
+        }
+
+        public void RemoveAgentToGroupInvite(UUID requestingAgentID, UUID inviteID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            GroupInviteInfo invite = GetAgentToGroupInvite(requestingAgentID, inviteID);
+            SimianRemoveGenericEntry(invite.GroupID, "GroupMemberInvite", inviteID.ToString());
+        }
+
+        public void AddAgentToGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // Setup Agent/Group information
+            SetAgentGroupInfo(requestingAgentID, AgentID, GroupID, true, true);
+
+            // Add agent to Everyone Group
+            AddAgentToGroupRole(requestingAgentID, AgentID, GroupID, UUID.Zero);
+
+            // Add agent to Specified Role
+            AddAgentToGroupRole(requestingAgentID, AgentID, GroupID, RoleID);
+
+            // Set selected role in this group to specified role
+            SetAgentActiveGroupRole(requestingAgentID, AgentID, GroupID, RoleID);
+        }
+
+        public void RemoveAgentFromGroup(UUID requestingAgentID, UUID agentID, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // If current active group is the group the agent is being removed from, change their group to UUID.Zero
+            GroupMembershipData memberActiveMembership = GetAgentActiveMembership(requestingAgentID, agentID);
+            if (memberActiveMembership.GroupID == groupID)
+            {
+                SetAgentActiveGroup(agentID, agentID, UUID.Zero);
+            }
+
+            // Remove Group Member information for this group
+            SimianRemoveGenericEntry(agentID, "GroupMember", groupID.ToString());
+
+            // By using a Simian Generics Type consisting of a prefix and a groupID, 
+            // combined with RoleID as key allows us to get a list of roles a particular member
+            // of a group is assigned to.
+            string GroupRoleMemberType = "GroupRole" + groupID.ToString();
+
+            // Take Agent out of all other group roles
+            Dictionary<string, OSDMap> GroupRoles;
+            if (SimianGetGenericEntries(agentID, GroupRoleMemberType, out GroupRoles))
+            {
+                foreach (string roleID in GroupRoles.Keys)
+                {
+                    SimianRemoveGenericEntry(agentID, GroupRoleMemberType, roleID);
+                }
+            }
+        }
+
+        public void AddAgentToGroupRole(UUID requestingAgentID, UUID agentID, UUID groupID, UUID roleID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            SimianAddGeneric(agentID, "GroupRole" + groupID.ToString(), roleID.ToString(), new OSDMap());
+        }
+
+        public void RemoveAgentFromGroupRole(UUID requestingAgentID, UUID agentID, UUID groupID, UUID roleID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // Cannot remove members from the Everyone Role
+            if (roleID != UUID.Zero)
+            {
+                EnsureRoleNotSelectedByMember(groupID, roleID, agentID);
+
+                string GroupRoleMemberType = "GroupRole" + groupID.ToString();
+                SimianRemoveGenericEntry(agentID, GroupRoleMemberType, roleID.ToString());
+            }
+        }
+
+        public List<DirGroupsReplyData> FindGroups(UUID requestingAgentID, string search)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            List<DirGroupsReplyData> findings = new List<DirGroupsReplyData>();
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetGenerics" },
+                { "Type", "Group" },
+                { "Key", search },
+                { "Fuzzy", "1" }
+            };
+
+
+            OSDMap response = CachedPostRequest(requestArgs);
+            if (response["Success"].AsBoolean() && response["Entries"] is OSDArray)
+            {
+                OSDArray entryArray = (OSDArray)response["Entries"];
+                foreach (OSDMap entryMap in entryArray)
+                {
+                    DirGroupsReplyData data = new DirGroupsReplyData();
+                    data.groupID = entryMap["OwnerID"].AsUUID();
+                    data.groupName = entryMap["Key"].AsString();
+
+                    // TODO: is there a better way to do this?
+                    Dictionary<UUID, OSDMap> Members;
+                    if (SimianGetGenericEntries("GroupMember", data.groupID.ToString(), out Members))
+                    {
+                        data.members = Members.Count;
+                    }
+                    else
+                    {
+                        data.members = 0;
+                    }
+                    
+                    // TODO: sort results?
+                    // data.searchOrder = order;
+
+                    findings.Add(data);
+                }
+            }
+
+            return findings;
+        }
+
+        public GroupMembershipData GetAgentGroupMembership(UUID requestingAgentID, UUID agentID, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            GroupMembershipData data = null;
+//            bool foundData = false;
+
+            OSDMap UserGroupMemberInfo;
+            if (SimianGetGenericEntry(agentID, "GroupMember", groupID.ToString(), out UserGroupMemberInfo))
+            {
+                data = new GroupMembershipData();
+                data.AcceptNotices = UserGroupMemberInfo["AcceptNotices"].AsBoolean();
+                data.Contribution = UserGroupMemberInfo["Contribution"].AsInteger();
+                data.ListInProfile = UserGroupMemberInfo["ListInProfile"].AsBoolean();
+                data.ActiveRole = UserGroupMemberInfo["SelectedRoleID"].AsUUID();         
+                
+                ///////////////////////////////
+                // Agent Specific Information:
+                //
+                OSDMap UserActiveGroup;
+                if (SimianGetGenericEntry(agentID, "Group", "ActiveGroup", out UserActiveGroup))
+                {
+                    data.Active = UserActiveGroup["GroupID"].AsUUID().Equals(groupID);
+                }                
+
+                ///////////////////////////////
+                // Role Specific Information:
+                //
+                OSDMap GroupRoleInfo;
+                if (SimianGetGenericEntry(groupID, "GroupRole", data.ActiveRole.ToString(), out GroupRoleInfo))
+                {
+                    data.GroupTitle = GroupRoleInfo["Title"].AsString();
+                    data.GroupPowers = GroupRoleInfo["Powers"].AsULong();
+                }                
+                
+                ///////////////////////////////
+                // Group Specific Information:
+                //
+                OSDMap GroupInfo;
+                string GroupName;
+                if (SimianGetFirstGenericEntry(groupID, "Group", out GroupName, out GroupInfo))
+                {
+                    data.GroupID = groupID;
+                    data.AllowPublish = GroupInfo["AllowPublish"].AsBoolean();
+                    data.Charter = GroupInfo["Charter"].AsString();
+                    data.FounderID = GroupInfo["FounderID"].AsUUID();
+                    data.GroupName = GroupName;
+                    data.GroupPicture = GroupInfo["InsigniaID"].AsUUID();
+                    data.MaturePublish = GroupInfo["MaturePublish"].AsBoolean();
+                    data.MembershipFee = GroupInfo["MembershipFee"].AsInteger();
+                    data.OpenEnrollment = GroupInfo["OpenEnrollment"].AsBoolean();
+                    data.ShowInList = GroupInfo["ShowInList"].AsBoolean();
+                }                       
+            }
+
+            return data;
+        }
+
+        public GroupMembershipData GetAgentActiveMembership(UUID requestingAgentID, UUID agentID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            UUID GroupID = UUID.Zero;
+            OSDMap UserActiveGroup;
+            if (SimianGetGenericEntry(agentID, "Group", "ActiveGroup", out UserActiveGroup))
+            {
+                GroupID = UserActiveGroup["GroupID"].AsUUID();
+            }
+
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  Active GroupID : {0}", GroupID.ToString());
+            return GetAgentGroupMembership(requestingAgentID, agentID, GroupID);
+        }
+
+        public List<GroupMembershipData> GetAgentGroupMemberships(UUID requestingAgentID, UUID agentID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            List<GroupMembershipData> memberships = new List<GroupMembershipData>();
+
+            Dictionary<string,OSDMap> GroupMemberShips;
+            if (SimianGetGenericEntries(agentID, "GroupMember", out GroupMemberShips))
+            {
+                foreach (string key in GroupMemberShips.Keys)
+                {
+                    memberships.Add(GetAgentGroupMembership(requestingAgentID, agentID, UUID.Parse(key)));
+                }
+            }
+            
+            return memberships;
+        }
+
+        public List<GroupRolesData> GetAgentGroupRoles(UUID requestingAgentID, UUID agentID, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            List<GroupRolesData> Roles = new List<GroupRolesData>();
+
+            Dictionary<string, OSDMap> GroupRoles;
+            if (SimianGetGenericEntries(groupID, "GroupRole", out GroupRoles))
+            {
+                Dictionary<string, OSDMap> MemberRoles;
+                if (SimianGetGenericEntries(agentID, "GroupRole" + groupID.ToString(), out MemberRoles))
+                {
+                    foreach (KeyValuePair<string, OSDMap> kvp in MemberRoles)
+                    {
+                        GroupRolesData data = new GroupRolesData();
+                        data.RoleID = UUID.Parse(kvp.Key);
+                        data.Name = GroupRoles[kvp.Key]["Name"].AsString();
+                        data.Description = GroupRoles[kvp.Key]["Description"].AsString();
+                        data.Title = GroupRoles[kvp.Key]["Title"].AsString();
+                        data.Powers = GroupRoles[kvp.Key]["Powers"].AsULong();
+
+                        Roles.Add(data);
+                    }
+                }
+            }
+            return Roles;
+        }
+
+        public List<GroupRolesData> GetGroupRoles(UUID requestingAgentID, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            List<GroupRolesData> Roles = new List<GroupRolesData>();
+
+            Dictionary<string, OSDMap> GroupRoles;
+            if (SimianGetGenericEntries(groupID, "GroupRole", out GroupRoles))
+            {
+                foreach (KeyValuePair<string, OSDMap> role in GroupRoles)
+                {
+                    GroupRolesData data = new GroupRolesData();
+
+                    data.RoleID = UUID.Parse(role.Key);
+
+                    data.Name = role.Value["Name"].AsString();
+                    data.Description = role.Value["Description"].AsString();
+                    data.Title = role.Value["Title"].AsString();
+                    data.Powers = role.Value["Powers"].AsULong();
+
+                    Dictionary<UUID, OSDMap> GroupRoleMembers;
+                    if (SimianGetGenericEntries("GroupRole" + groupID.ToString(), role.Key, out GroupRoleMembers))
+                    {
+                        data.Members = GroupRoleMembers.Count;
+                    }
+                    else
+                    {
+                        data.Members = 0;
+                    }
+
+                    Roles.Add(data);
+                }
+            }
+
+            return Roles;
+
+        }
+
+
+
+        public List<GroupMembersData> GetGroupMembers(UUID requestingAgentID, UUID GroupID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            List<GroupMembersData> members = new List<GroupMembersData>();
+
+            OSDMap GroupInfo;
+            string GroupName;
+            UUID GroupOwnerRoleID = UUID.Zero;
+            if (!SimianGetFirstGenericEntry(GroupID, "Group", out GroupName, out GroupInfo))
+            {
+                return members;
+            }
+            GroupOwnerRoleID = GroupInfo["OwnerRoleID"].AsUUID();
+
+            // Locally cache group roles, since we'll be needing this data for each member
+            Dictionary<string,OSDMap> GroupRoles;
+            SimianGetGenericEntries(GroupID, "GroupRole", out GroupRoles);
+
+            // Locally cache list of group owners
+            Dictionary<UUID, OSDMap> GroupOwners;
+            SimianGetGenericEntries("GroupRole" + GroupID.ToString(), GroupOwnerRoleID.ToString(), out GroupOwners);
+
+
+            Dictionary<UUID, OSDMap> GroupMembers;
+            if (SimianGetGenericEntries("GroupMember", GroupID.ToString(), out GroupMembers))
+            {
+                foreach (KeyValuePair<UUID, OSDMap> member in GroupMembers)
+                {
+                    GroupMembersData data = new GroupMembersData();
+
+                    data.AgentID = member.Key;
+
+                    UUID SelectedRoleID = member.Value["SelectedRoleID"].AsUUID();
+
+                    data.AcceptNotices = member.Value["AcceptNotices"].AsBoolean();
+                    data.ListInProfile = member.Value["ListInProfile"].AsBoolean();
+                    data.Contribution = member.Value["Contribution"].AsInteger();
+
+                    data.IsOwner = GroupOwners.ContainsKey(member.Key);
+
+                    OSDMap GroupRoleInfo = GroupRoles[SelectedRoleID.ToString()];
+                    data.Title = GroupRoleInfo["Title"].AsString();
+                    data.AgentPowers = GroupRoleInfo["Powers"].AsULong();
+
+                    members.Add(data);
+                }
+            }
+
+            return members;
+
+        }
+
+        public List<GroupRoleMembersData> GetGroupRoleMembers(UUID requestingAgentID, UUID groupID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            List<GroupRoleMembersData> members = new List<GroupRoleMembersData>();
+
+            Dictionary<string, OSDMap> GroupRoles;
+            if (SimianGetGenericEntries(groupID, "GroupRole", out GroupRoles))
+            {
+                foreach (KeyValuePair<string, OSDMap> Role in GroupRoles)
+                {
+                    Dictionary<UUID, OSDMap> GroupRoleMembers;
+                    if (SimianGetGenericEntries("GroupRole"+groupID.ToString(), Role.Key, out GroupRoleMembers))
+                    {
+                        foreach (KeyValuePair<UUID, OSDMap> GroupRoleMember in GroupRoleMembers)
+                        {
+                            GroupRoleMembersData data = new GroupRoleMembersData();
+
+                            data.MemberID = GroupRoleMember.Key;
+                            data.RoleID = UUID.Parse(Role.Key);
+
+                            members.Add(data);
+                        }
+                    }
+                }
+            }
+
+            return members;
+        }
+
+        public List<GroupNoticeData> GetGroupNotices(UUID requestingAgentID, UUID GroupID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            List<GroupNoticeData> values = new List<GroupNoticeData>();
+
+            Dictionary<string, OSDMap> Notices;
+            if (SimianGetGenericEntries(GroupID, "GroupNotice", out Notices))
+            {
+                foreach (KeyValuePair<string, OSDMap> Notice in Notices)
+                {
+                    GroupNoticeData data = new GroupNoticeData();
+                    data.NoticeID = UUID.Parse(Notice.Key);
+                    data.Timestamp = Notice.Value["TimeStamp"].AsUInteger();
+                    data.FromName = Notice.Value["FromName"].AsString();
+                    data.Subject = Notice.Value["Subject"].AsString();
+                    data.HasAttachment = Notice.Value["BinaryBucket"].AsBinary().Length > 0;
+
+                    //TODO: Figure out how to get this
+                    data.AssetType = 0;
+
+                    values.Add(data);
+                }
+            }
+
+            return values;
+
+        }
+        public GroupNoticeInfo GetGroupNotice(UUID requestingAgentID, UUID noticeID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap GroupNotice;
+            UUID GroupID;
+            if (SimianGetFirstGenericEntry("GroupNotice", noticeID.ToString(), out GroupID, out GroupNotice))
+            {
+                GroupNoticeInfo data = new GroupNoticeInfo();
+                data.GroupID = GroupID;
+                data.Message = GroupNotice["Message"].AsString();
+                data.BinaryBucket = GroupNotice["BinaryBucket"].AsBinary();
+                data.noticeData.NoticeID = noticeID;
+                data.noticeData.Timestamp = GroupNotice["TimeStamp"].AsUInteger();
+                data.noticeData.FromName = GroupNotice["FromName"].AsString();
+                data.noticeData.Subject = GroupNotice["Subject"].AsString();
+                data.noticeData.HasAttachment = data.BinaryBucket.Length > 0;
+                data.noticeData.AssetType = 0;
+
+                if (data.Message == null)
+                {
+                    data.Message = string.Empty;
+                }
+
+                return data;
+            }
+            return null;
+        }
+        public void AddGroupNotice(UUID requestingAgentID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            OSDMap Notice = new OSDMap();
+            Notice["TimeStamp"] = OSD.FromUInteger((uint)Util.UnixTimeSinceEpoch());
+            Notice["FromName"] = OSD.FromString(fromName);
+            Notice["Subject"] = OSD.FromString(subject);
+            Notice["Message"] = OSD.FromString(message);
+            Notice["BinaryBucket"] = OSD.FromBinary(binaryBucket);
+
+            SimianAddGeneric(groupID, "GroupNotice", noticeID.ToString(), Notice);
+            
+        }
+        #endregion
+
+        #region GroupSessionTracking
+
+        public void ResetAgentGroupChatSessions(UUID agentID)
+        {
+            Dictionary<string, OSDMap> agentSessions;
+
+            if (SimianGetGenericEntries(agentID, "GroupSessionDropped", out agentSessions))
+            {
+                foreach (string GroupID in agentSessions.Keys)
+                {
+                    SimianRemoveGenericEntry(agentID, "GroupSessionDropped", GroupID);
+                }
+            }
+
+            if (SimianGetGenericEntries(agentID, "GroupSessionInvited", out agentSessions))
+            {
+                foreach (string GroupID in agentSessions.Keys)
+                {
+                    SimianRemoveGenericEntry(agentID, "GroupSessionInvited", GroupID);
+                }
+            }
+        }
+
+        public bool hasAgentDroppedGroupChatSession(UUID agentID, UUID groupID)
+        {
+            OSDMap session;
+            return SimianGetGenericEntry(agentID, "GroupSessionDropped", groupID.ToString(), out session);
+        }
+
+        public void AgentDroppedFromGroupChatSession(UUID agentID, UUID groupID)
+        {
+            SimianAddGeneric(agentID, "GroupSessionDropped", groupID.ToString(), new OSDMap());
+        }
+
+        public void AgentInvitedToGroupChatSession(UUID agentID, UUID groupID)
+        {
+            SimianAddGeneric(agentID, "GroupSessionInvited", groupID.ToString(), new OSDMap());
+        }
+
+        public bool hasAgentBeenInvitedToGroupChatSession(UUID agentID, UUID groupID)
+        {
+            OSDMap session;
+            return SimianGetGenericEntry(agentID, "GroupSessionDropped", groupID.ToString(), out session);
+        }
+
+        #endregion
+
+        private void EnsureRoleNotSelectedByMember(UUID groupID, UUID roleID, UUID userID)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            // If member's SelectedRole is roleID, change their selected role to Everyone
+            // before removing them from the role
+            OSDMap UserGroupInfo;
+            if (SimianGetGenericEntry(userID, "GroupMember", groupID.ToString(), out UserGroupInfo))
+            {
+                if (UserGroupInfo["SelectedRoleID"].AsUUID() == roleID)
+                {
+                    UserGroupInfo["SelectedRoleID"] = OSD.FromUUID(UUID.Zero);
+                }
+                SimianAddGeneric(userID, "GroupMember", groupID.ToString(), UserGroupInfo);
+            }
+        }
+
+
+        #region Simian Util Methods
+        private bool SimianAddGeneric(UUID ownerID, string type, string key, OSDMap map)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called ({1},{2},{3})", System.Reflection.MethodBase.GetCurrentMethod().Name, ownerID, type, key);
+
+            string value = OSDParser.SerializeJsonString(map);
+
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  value: {0}", value);
+
+            NameValueCollection RequestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "AddGeneric" },
+                { "OwnerID", ownerID.ToString() },
+                { "Type", type },
+                { "Key", key },
+                { "Value", value}
+            };
+
+
+            OSDMap Response = CachedPostRequest(RequestArgs);
+            if (Response["Success"].AsBoolean())
+            {
+                return true;
+            }
+            else
+            {
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: Error {0}, {1}, {2}, {3}", ownerID, type, key, Response["Message"]);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Returns the first of possibly many entries for Owner/Type pair
+        /// </summary>
+        private bool SimianGetFirstGenericEntry(UUID ownerID, string type, out string key, out OSDMap map)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called ({1},{2})", System.Reflection.MethodBase.GetCurrentMethod().Name, ownerID, type);
+
+            NameValueCollection RequestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetGenerics" },
+                { "OwnerID", ownerID.ToString() },
+                { "Type", type }
+            };
+
+
+            OSDMap Response = CachedPostRequest(RequestArgs);
+            if (Response["Success"].AsBoolean() && Response["Entries"] is OSDArray)
+            {
+                OSDArray entryArray = (OSDArray)Response["Entries"];
+                if (entryArray.Count >= 1)
+                {
+                    OSDMap entryMap = entryArray[0] as OSDMap;
+                    key = entryMap["Key"].AsString();
+                    map = (OSDMap)OSDParser.DeserializeJson(entryMap["Value"].AsString());
+
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  Generics Result {0}", entryMap["Value"].AsString());
+
+                    return true;
+                }
+                else
+                {
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  No Generics Results");
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: Error retrieving group info ({0})", Response["Message"]);
+            }
+            key = null;
+            map = null;
+            return false;
+        }
+        private bool SimianGetFirstGenericEntry(string type, string key, out UUID ownerID, out OSDMap map)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called ({1},{2})", System.Reflection.MethodBase.GetCurrentMethod().Name, type, key);
+
+
+            NameValueCollection RequestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetGenerics" },
+                { "Type", type },
+                { "Key", key}
+            };
+
+
+            OSDMap Response = CachedPostRequest(RequestArgs);
+            if (Response["Success"].AsBoolean() && Response["Entries"] is OSDArray)
+            {
+                OSDArray entryArray = (OSDArray)Response["Entries"];
+                if (entryArray.Count >= 1)
+                {
+                    OSDMap entryMap = entryArray[0] as OSDMap;
+                    ownerID = entryMap["OwnerID"].AsUUID();
+                    map = (OSDMap)OSDParser.DeserializeJson(entryMap["Value"].AsString());
+
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  Generics Result {0}", entryMap["Value"].AsString());
+
+                    return true;
+                }
+                else
+                {
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  No Generics Results");
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: Error retrieving group info ({0})", Response["Message"]);
+            }
+            ownerID = UUID.Zero;
+            map = null;
+            return false;
+        }
+
+        private bool SimianGetGenericEntry(UUID ownerID, string type, string key, out OSDMap map)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called ({1},{2},{3})", System.Reflection.MethodBase.GetCurrentMethod().Name, ownerID, type, key);
+
+            NameValueCollection RequestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetGenerics" },
+                { "OwnerID", ownerID.ToString() },
+                { "Type", type },
+                { "Key", key}
+            };
+
+
+            OSDMap Response = CachedPostRequest(RequestArgs);
+            if (Response["Success"].AsBoolean() && Response["Entries"] is OSDArray)
+            {
+                OSDArray entryArray = (OSDArray)Response["Entries"];
+                if (entryArray.Count == 1)
+                {
+                    OSDMap entryMap = entryArray[0] as OSDMap;
+                    key = entryMap["Key"].AsString();
+                    map = (OSDMap)OSDParser.DeserializeJson(entryMap["Value"].AsString());
+
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  Generics Result {0}", entryMap["Value"].AsString());
+
+                    return true;
+                }
+                else
+                {
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  No Generics Results");
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: Error retrieving group info ({0})", Response["Message"]);
+            }
+            map = null;
+            return false;
+        }
+
+        private bool SimianGetGenericEntries(UUID ownerID, string type, out Dictionary<string, OSDMap> maps)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called ({1},{2})", System.Reflection.MethodBase.GetCurrentMethod().Name,ownerID, type);
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetGenerics" },
+                { "OwnerID", ownerID.ToString() },
+                { "Type", type }
+            };
+            
+
+
+            OSDMap response = CachedPostRequest(requestArgs);
+            if (response["Success"].AsBoolean() && response["Entries"] is OSDArray)
+            {
+                maps = new Dictionary<string, OSDMap>();
+
+                OSDArray entryArray = (OSDArray)response["Entries"];
+                foreach (OSDMap entryMap in entryArray)
+                {
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  Generics Result {0}", entryMap["Value"].AsString());
+                    maps.Add(entryMap["Key"].AsString(), (OSDMap)OSDParser.DeserializeJson(entryMap["Value"].AsString()));
+                }
+                if (maps.Count == 0)
+                {
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  No Generics Results");
+                }
+
+                return true;
+            }
+            else
+            {
+                maps = null;
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: Error retrieving group info ({0})", response["Message"]);
+            }
+            return false;
+        }
+        private bool SimianGetGenericEntries(string type, string key, out Dictionary<UUID, OSDMap> maps)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called ({1},{2})", System.Reflection.MethodBase.GetCurrentMethod().Name, type, key);
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "GetGenerics" },
+                { "Type", type },
+                { "Key", key }
+            };
+
+
+
+            OSDMap response = CachedPostRequest(requestArgs);
+            if (response["Success"].AsBoolean() && response["Entries"] is OSDArray)
+            {
+                maps = new Dictionary<UUID, OSDMap>();
+
+                OSDArray entryArray = (OSDArray)response["Entries"];
+                foreach (OSDMap entryMap in entryArray)
+                {
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  Generics Result {0}", entryMap["Value"].AsString());
+                    maps.Add(entryMap["OwnerID"].AsUUID(), (OSDMap)OSDParser.DeserializeJson(entryMap["Value"].AsString()));
+                }
+                if (maps.Count == 0)
+                {
+                    if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  No Generics Results");
+                }
+                return true;
+            }
+            else
+            {
+                maps = null;
+                m_log.WarnFormat("[SIMIAN-GROUPS-CONNECTOR]: Error retrieving group info ({0})", response["Message"]);
+            }
+            return false;
+        }
+
+        private bool SimianRemoveGenericEntry(UUID ownerID, string type, string key)
+        {
+            if (m_debugEnabled) m_log.InfoFormat("[SIMIAN-GROUPS-CONNECTOR]  {0} called ({1},{2},{3})", System.Reflection.MethodBase.GetCurrentMethod().Name, ownerID, type, key);
+
+            NameValueCollection requestArgs = new NameValueCollection
+            {
+                { "RequestMethod", "RemoveGeneric" },
+                { "OwnerID", ownerID.ToString() },
+                { "Type", type },
+                { "Key", key }
+            };
+
+
+            OSDMap response = CachedPostRequest(requestArgs);
+            if (response["Success"].AsBoolean())
+            {
+                return true;
+            }
+            else
+            {
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: Error {0}, {1}, {2}, {3}", ownerID, type, key, response["Message"]);
+                return false;
+            }
+        }
+        #endregion
+
+        #region CheesyCache
+        OSDMap CachedPostRequest(NameValueCollection requestArgs)
+        {
+            // Immediately forward the request if the cache is disabled.
+            if (m_cacheTimeout == 0)
+            {
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: cache is disabled");
+                return WebUtil.PostToService(m_groupsServerURI, requestArgs);
+            }
+
+            // Check if this is an update or a request
+            if (requestArgs["RequestMethod"] == "RemoveGeneric"
+                || requestArgs["RequestMethod"] == "AddGeneric")
+            {
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: clearing generics cache");
+                
+                // Any and all updates cause the cache to clear
+                m_memoryCache.Clear();
+
+                // Send update to server, return the response without caching it
+                return WebUtil.PostToService(m_groupsServerURI, requestArgs);
+            }
+
+            // If we're not doing an update, we must be requesting data
+
+            // Create the cache key for the request and see if we have it cached
+            string CacheKey = WebUtil.BuildQueryString(requestArgs);
+
+            // This code uses a leader/follower pattern. On a cache miss, the request is added
+            // to a queue; the first thread to add it to the queue completes the request while
+            // follow on threads busy wait for the results, this situation seems to happen
+            // often when checking permissions
+            while (true)
+            {
+                OSDMap response = null;
+                bool firstRequest = false;
+
+                lock (m_memoryCache)
+                {
+                    if (m_memoryCache.TryGetValue(CacheKey, out response))
+                        return response;
+                    
+                    if (! m_pendingRequests.ContainsKey(CacheKey))
+                    {
+                        m_pendingRequests.Add(CacheKey,true);
+                        firstRequest = true;
+                    }
+                }
+                
+                if (firstRequest)
+                {
+                    // if it wasn't in the cache, pass the request to the Simian Grid Services
+                    try
+                    {
+                        response = WebUtil.PostToService(m_groupsServerURI, requestArgs);
+                    }
+                    catch (Exception)
+                    {
+                        m_log.ErrorFormat("[SIMIAN GROUPS CONNECTOR]: request failed {0}", CacheKey);
+                    }
+                    
+                    // and cache the response
+                    lock (m_memoryCache)
+                    {
+                        m_memoryCache.AddOrUpdate(CacheKey, response, TimeSpan.FromSeconds(m_cacheTimeout));
+                        m_pendingRequests.Remove(CacheKey);
+                    }
+
+                    return response;
+                }
+
+                Thread.Sleep(50); // waiting for a web request to complete, 50msecs is reasonable
+            }
+
+            // if (!m_memoryCache.TryGetValue(CacheKey, out response))
+            // {
+            //     m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: query not in the cache");
+            //     Util.PrintCallStack();
+                
+            //     // if it wasn't in the cache, pass the request to the Simian Grid Services
+            //     response = WebUtil.PostToService(m_groupsServerURI, requestArgs);
+
+            //     // and cache the response
+            //     m_memoryCache.AddOrUpdate(CacheKey, response, TimeSpan.FromSeconds(m_cacheTimeout));
+            // }
+
+            // // return cached response
+            // return response;
+        }
+        #endregion
+
+    }
+
+}
+
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/Tests/GroupsModuleTests.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/Tests/GroupsModuleTests.cs
new file mode 100644
index 0000000..e03e71d
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/Tests/GroupsModuleTests.cs
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Messages.Linden;
+using OpenMetaverse.Packets;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.ClientStack.Linden;
+using OpenSim.Region.CoreModules.Avatar.InstantMessage;
+using OpenSim.Region.CoreModules.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups.Tests
+{
+    /// <summary>
+    /// Basic groups module tests
+    /// </summary>
+    [TestFixture]
+    public class GroupsModuleTests : OpenSimTestCase
+    {
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            uint port = 9999;
+            uint sslPort = 9998;
+
+            // This is an unfortunate bit of clean up we have to do because MainServer manages things through static
+            // variables and the VM is not restarted between tests.
+            MainServer.RemoveHttpServer(port);
+
+            BaseHttpServer server = new BaseHttpServer(port, false, sslPort, "");
+            MainServer.AddHttpServer(server);
+            MainServer.Instance = server;
+        }
+
+        [Test]
+        public void TestSendAgentGroupDataUpdate()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            
+            TestScene scene = new SceneHelpers().SetupScene();
+            IConfigSource configSource = new IniConfigSource();
+            IConfig config = configSource.AddConfig("Groups");            
+            config.Set("Enabled", true);
+            config.Set("Module", "GroupsModule");            
+            config.Set("DebugEnabled", true);
+
+            GroupsModule gm = new GroupsModule();
+            EventQueueGetModule eqgm = new EventQueueGetModule();
+
+            // We need a capabilities module active so that adding the scene presence creates an event queue in the
+            // EventQueueGetModule
+            SceneHelpers.SetupSceneModules(
+                scene, configSource, gm, new MockGroupsServicesConnector(), new CapabilitiesModule(), eqgm);
+
+            ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseStem("1"));
+
+            gm.SendAgentGroupDataUpdate(sp.ControllingClient);
+
+            Hashtable eventsResponse = eqgm.GetEvents(UUID.Zero, sp.UUID);
+
+            Assert.That((int)eventsResponse["int_response_code"], Is.EqualTo((int)HttpStatusCode.OK));
+
+//            Console.WriteLine("Response [{0}]", (string)eventsResponse["str_response_string"]);
+
+            OSDMap rawOsd = (OSDMap)OSDParser.DeserializeLLSDXml((string)eventsResponse["str_response_string"]);
+            OSDArray eventsOsd = (OSDArray)rawOsd["events"];
+
+            bool foundUpdate = false;
+            foreach (OSD osd in eventsOsd)
+            {
+                OSDMap eventOsd = (OSDMap)osd;
+
+                if (eventOsd["message"] == "AgentGroupDataUpdate")
+                    foundUpdate = true;
+            }
+
+            Assert.That(foundUpdate, Is.True, "Did not find AgentGroupDataUpdate in response");
+
+            // TODO: More checking of more actual event data.           
+        }
+
+        [Test]
+        public void TestSendGroupNotice()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+            
+            TestScene scene = new SceneHelpers().SetupScene();
+
+            MessageTransferModule mtm = new MessageTransferModule();
+            GroupsModule gm = new GroupsModule();
+            GroupsMessagingModule gmm = new GroupsMessagingModule();
+            MockGroupsServicesConnector mgsc = new MockGroupsServicesConnector();
+
+            IConfigSource configSource = new IniConfigSource();
+
+            {
+                IConfig config = configSource.AddConfig("Messaging");            
+                config.Set("MessageTransferModule", mtm.Name);
+            }
+
+            {
+                IConfig config = configSource.AddConfig("Groups");            
+                config.Set("Enabled", true);
+                config.Set("Module", gm.Name);
+                config.Set("DebugEnabled", true);
+                config.Set("MessagingModule", gmm.Name);
+                config.Set("MessagingEnabled", true);
+            }
+
+            SceneHelpers.SetupSceneModules(scene, configSource, mgsc, mtm, gm, gmm);
+
+            UUID userId = TestHelpers.ParseTail(0x1);
+            string subjectText = "newman";
+            string messageText = "Hello";
+            string combinedSubjectMessage = string.Format("{0}|{1}", subjectText, messageText);
+
+            ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x1));
+            TestClient tc = (TestClient)sp.ControllingClient;
+
+            UUID groupID = gm.CreateGroup(tc, "group1", null, true, UUID.Zero, 0, true, true, true);
+            gm.JoinGroupRequest(tc, groupID);
+
+            // Create a second user who doesn't want to receive notices
+            ScenePresence sp2 = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x2));
+            TestClient tc2 = (TestClient)sp2.ControllingClient;
+            gm.JoinGroupRequest(tc2, groupID);
+            gm.SetGroupAcceptNotices(tc2, groupID, false, true);
+
+            List<GridInstantMessage> spReceivedMessages = new List<GridInstantMessage>();
+            tc.OnReceivedInstantMessage += im => spReceivedMessages.Add(im);
+
+            List<GridInstantMessage> sp2ReceivedMessages = new List<GridInstantMessage>();
+            tc2.OnReceivedInstantMessage += im => sp2ReceivedMessages.Add(im);
+
+            GridInstantMessage noticeIm = new GridInstantMessage();
+            noticeIm.fromAgentID = userId.Guid;
+            noticeIm.toAgentID = groupID.Guid;
+            noticeIm.message = combinedSubjectMessage;
+            noticeIm.dialog = (byte)InstantMessageDialog.GroupNotice;
+
+            tc.HandleImprovedInstantMessage(noticeIm);
+
+            Assert.That(spReceivedMessages.Count, Is.EqualTo(1));
+            Assert.That(spReceivedMessages[0].message, Is.EqualTo(combinedSubjectMessage));
+
+            List<GroupNoticeData> notices = mgsc.GetGroupNotices(UUID.Zero, groupID);
+            Assert.AreEqual(1, notices.Count);
+
+            // OpenSimulator (possibly also SL) transport the notice ID as the session ID!
+            Assert.AreEqual(notices[0].NoticeID.Guid, spReceivedMessages[0].imSessionID);
+
+            Assert.That(sp2ReceivedMessages.Count, Is.EqualTo(0));
+        }
+
+        /// <summary>
+        /// Run test with the MessageOnlineUsersOnly flag set.
+        /// </summary>
+        [Test]
+        public void TestSendGroupNoticeOnlineOnly()
+        {
+            TestHelpers.InMethod();
+            //            TestHelpers.EnableLogging();
+
+            TestScene scene = new SceneHelpers().SetupScene();
+
+            MessageTransferModule mtm = new MessageTransferModule();
+            GroupsModule gm = new GroupsModule();
+            GroupsMessagingModule gmm = new GroupsMessagingModule();
+
+            IConfigSource configSource = new IniConfigSource();
+
+            {
+                IConfig config = configSource.AddConfig("Messaging");
+                config.Set("MessageTransferModule", mtm.Name);
+            }
+
+            {
+                IConfig config = configSource.AddConfig("Groups");
+                config.Set("Enabled", true);
+                config.Set("Module", gm.Name);
+                config.Set("DebugEnabled", true);
+                config.Set("MessagingModule", gmm.Name);
+                config.Set("MessagingEnabled", true);
+                config.Set("MessageOnlineUsersOnly", true);
+            }
+
+            SceneHelpers.SetupSceneModules(scene, configSource, new MockGroupsServicesConnector(), mtm, gm, gmm);
+
+            UUID userId = TestHelpers.ParseTail(0x1);
+            string subjectText = "newman";
+            string messageText = "Hello";
+            string combinedSubjectMessage = string.Format("{0}|{1}", subjectText, messageText);
+
+            ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x1));
+            TestClient tc = (TestClient)sp.ControllingClient;
+
+            UUID groupID = gm.CreateGroup(tc, "group1", null, true, UUID.Zero, 0, true, true, true);
+            gm.JoinGroupRequest(tc, groupID);
+
+            // Create a second user who doesn't want to receive notices
+            ScenePresence sp2 = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x2));
+            TestClient tc2 = (TestClient)sp2.ControllingClient;
+            gm.JoinGroupRequest(tc2, groupID);
+            gm.SetGroupAcceptNotices(tc2, groupID, false, true);
+
+            List<GridInstantMessage> spReceivedMessages = new List<GridInstantMessage>();
+            tc.OnReceivedInstantMessage += im => spReceivedMessages.Add(im);
+
+            List<GridInstantMessage> sp2ReceivedMessages = new List<GridInstantMessage>();
+            tc2.OnReceivedInstantMessage += im => sp2ReceivedMessages.Add(im);
+
+            GridInstantMessage noticeIm = new GridInstantMessage();
+            noticeIm.fromAgentID = userId.Guid;
+            noticeIm.toAgentID = groupID.Guid;
+            noticeIm.message = combinedSubjectMessage;
+            noticeIm.dialog = (byte)InstantMessageDialog.GroupNotice;
+
+            tc.HandleImprovedInstantMessage(noticeIm);
+
+            Assert.That(spReceivedMessages.Count, Is.EqualTo(1));
+            Assert.That(spReceivedMessages[0].message, Is.EqualTo(combinedSubjectMessage));
+
+            Assert.That(sp2ReceivedMessages.Count, Is.EqualTo(0));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs
new file mode 100644
index 0000000..a040f43
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/XmlRpcGroupsServicesConnectorModule.cs
@@ -0,0 +1,1174 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+
+using Nwc.XmlRpc;
+
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Communications;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+
+namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "XmlRpcGroupsServicesConnectorModule")]
+    public class XmlRpcGroupsServicesConnectorModule : ISharedRegionModule, IGroupsServicesConnector
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private bool m_debugEnabled = false;
+
+        public const GroupPowers DefaultEveryonePowers 
+            = GroupPowers.AllowSetHome 
+                | GroupPowers.Accountable 
+                | GroupPowers.JoinChat 
+                | GroupPowers.AllowVoiceChat 
+                | GroupPowers.ReceiveNotices 
+                | GroupPowers.StartProposal 
+                | GroupPowers.VoteOnProposal;
+
+        // Would this be cleaner as (GroupPowers)ulong.MaxValue?
+        public const GroupPowers DefaultOwnerPowers 
+            = GroupPowers.Accountable
+                | GroupPowers.AllowEditLand
+                | GroupPowers.AllowFly
+                | GroupPowers.AllowLandmark
+                | GroupPowers.AllowRez
+                | GroupPowers.AllowSetHome
+                | GroupPowers.AllowVoiceChat
+                | GroupPowers.AssignMember
+                | GroupPowers.AssignMemberLimited
+                | GroupPowers.ChangeActions
+                | GroupPowers.ChangeIdentity
+                | GroupPowers.ChangeMedia
+                | GroupPowers.ChangeOptions
+                | GroupPowers.CreateRole
+                | GroupPowers.DeedObject
+                | GroupPowers.DeleteRole
+                | GroupPowers.Eject
+                | GroupPowers.FindPlaces
+                | GroupPowers.Invite
+                | GroupPowers.JoinChat
+                | GroupPowers.LandChangeIdentity
+                | GroupPowers.LandDeed
+                | GroupPowers.LandDivideJoin
+                | GroupPowers.LandEdit
+                | GroupPowers.LandEjectAndFreeze
+                | GroupPowers.LandGardening
+                | GroupPowers.LandManageAllowed
+                | GroupPowers.LandManageBanned
+                | GroupPowers.LandManagePasses
+                | GroupPowers.LandOptions
+                | GroupPowers.LandRelease
+                | GroupPowers.LandSetSale
+                | GroupPowers.ModerateChat
+                | GroupPowers.ObjectManipulate
+                | GroupPowers.ObjectSetForSale
+                | GroupPowers.ReceiveNotices
+                | GroupPowers.RemoveMember
+                | GroupPowers.ReturnGroupOwned
+                | GroupPowers.ReturnGroupSet
+                | GroupPowers.ReturnNonGroup
+                | GroupPowers.RoleProperties
+                | GroupPowers.SendNotices
+                | GroupPowers.SetLandingPoint
+                | GroupPowers.StartProposal
+                | GroupPowers.VoteOnProposal;
+
+        private bool m_connectorEnabled = false;
+
+        private string m_groupsServerURI = string.Empty;
+
+        private bool m_disableKeepAlive = false;
+
+        private string m_groupReadKey  = string.Empty;
+        private string m_groupWriteKey = string.Empty;
+
+        private IUserAccountService m_accountService = null;
+
+        private ExpiringCache<string, XmlRpcResponse> m_memoryCache;
+        private int m_cacheTimeout = 30;
+
+        // Used to track which agents are have dropped from a group chat session
+        // Should be reset per agent, on logon
+        // TODO: move this to Flotsam XmlRpc Service
+        // SessionID, List<AgentID>
+        private Dictionary<UUID, List<UUID>> m_groupsAgentsDroppedFromChatSession = new Dictionary<UUID, List<UUID>>();
+        private Dictionary<UUID, List<UUID>> m_groupsAgentsInvitedToChatSession = new Dictionary<UUID, List<UUID>>();
+
+        #region Region Module interfaceBase Members
+
+        public string Name
+        {
+            get { return "XmlRpcGroupsServicesConnector"; }
+        }
+
+        // this module is not intended to be replaced, but there should only be 1 of them.
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource config)
+        {
+            IConfig groupsConfig = config.Configs["Groups"];
+
+            if (groupsConfig == null)
+            {
+                // Do not run this module by default.
+                return;
+            }
+            else
+            {
+                // if groups aren't enabled, we're not needed.
+                // if we're not specified as the connector to use, then we're not wanted
+                if ((groupsConfig.GetBoolean("Enabled", false) == false)
+                    || (groupsConfig.GetString("ServicesConnectorModule", "XmlRpcGroupsServicesConnector") != Name))
+                {
+                    m_connectorEnabled = false;
+                    return;
+                }
+
+                m_log.DebugFormat("[XMLRPC-GROUPS-CONNECTOR]: Initializing {0}", this.Name);
+
+                m_groupsServerURI = groupsConfig.GetString("GroupsServerURI", string.Empty);
+                if (string.IsNullOrEmpty(m_groupsServerURI))
+                {
+                    m_log.ErrorFormat("Please specify a valid URL for GroupsServerURI in OpenSim.ini, [Groups]");
+                    m_connectorEnabled = false;
+                    return;
+                }
+
+                m_disableKeepAlive = groupsConfig.GetBoolean("XmlRpcDisableKeepAlive", false);
+
+                m_groupReadKey = groupsConfig.GetString("XmlRpcServiceReadKey", string.Empty);
+                m_groupWriteKey = groupsConfig.GetString("XmlRpcServiceWriteKey", string.Empty);
+
+
+                m_cacheTimeout = groupsConfig.GetInt("GroupsCacheTimeout", 30);
+                if (m_cacheTimeout == 0)
+                {
+                    m_log.WarnFormat("[XMLRPC-GROUPS-CONNECTOR]: Groups Cache Disabled.");
+                }
+                else
+                {
+                    m_log.InfoFormat("[XMLRPC-GROUPS-CONNECTOR]: Groups Cache Timeout set to {0}.", m_cacheTimeout);
+                }
+
+                m_debugEnabled = groupsConfig.GetBoolean("DebugEnabled", false);
+
+                // If we got all the config options we need, lets start'er'up
+                m_memoryCache = new ExpiringCache<string, XmlRpcResponse>();
+                m_connectorEnabled = true;
+            }
+        }
+
+        public void Close()
+        {
+            m_log.DebugFormat("[XMLRPC-GROUPS-CONNECTOR]: Closing {0}", this.Name);
+        }
+
+        public void AddRegion(OpenSim.Region.Framework.Scenes.Scene scene)
+        {
+            if (m_connectorEnabled)
+            {
+
+                if (m_accountService == null)
+                {
+                    m_accountService = scene.UserAccountService;
+                }
+
+
+                scene.RegisterModuleInterface<IGroupsServicesConnector>(this);
+            }
+        }
+
+        public void RemoveRegion(OpenSim.Region.Framework.Scenes.Scene scene)
+        {
+            if (scene.RequestModuleInterface<IGroupsServicesConnector>() == this)
+            {
+                scene.UnregisterModuleInterface<IGroupsServicesConnector>(this);
+            }
+        }
+
+        public void RegionLoaded(OpenSim.Region.Framework.Scenes.Scene scene)
+        {
+            // TODO: May want to consider listenning for Agent Connections so we can pre-cache group info
+            // scene.EventManager.OnNewClient += OnNewClient;
+        }
+
+        #endregion
+
+        #region ISharedRegionModule Members
+
+        public void PostInitialise()
+        {
+            // NoOp
+        }
+
+        #endregion
+
+        #region IGroupsServicesConnector Members
+
+        /// <summary>
+        /// Create a Group, including Everyone and Owners Role, place FounderID in both groups, select Owner as selected role, and newly created group as agent's active role.
+        /// </summary>
+        public UUID CreateGroup(UUID requestingAgentID, string name, string charter, bool showInList, UUID insigniaID,
+                                int membershipFee, bool openEnrollment, bool allowPublish,
+                                bool maturePublish, UUID founderID)
+        {
+            UUID GroupID = UUID.Random();
+            UUID OwnerRoleID = UUID.Random();
+
+            Hashtable param = new Hashtable();
+            param["GroupID"] = GroupID.ToString();
+            param["Name"] = name;
+            param["Charter"] = charter;
+            param["ShowInList"] = showInList == true ? 1 : 0;
+            param["InsigniaID"] = insigniaID.ToString();
+            param["MembershipFee"] = membershipFee;
+            param["OpenEnrollment"] = openEnrollment == true ? 1 : 0;
+            param["AllowPublish"] = allowPublish == true ? 1 : 0;
+            param["MaturePublish"] = maturePublish == true ? 1 : 0;
+            param["FounderID"] = founderID.ToString();
+            param["EveryonePowers"] = ((ulong)DefaultEveryonePowers).ToString();
+            param["OwnerRoleID"] = OwnerRoleID.ToString();
+            param["OwnersPowers"] = ((ulong)DefaultOwnerPowers).ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.createGroup", param);
+
+            if (respData.Contains("error"))
+            {
+                // UUID is not nullable
+
+                return UUID.Zero;
+            }
+
+            return UUID.Parse((string)respData["GroupID"]);
+        }
+
+        public void UpdateGroup(UUID requestingAgentID, UUID groupID, string charter, bool showInList,
+                                UUID insigniaID, int membershipFee, bool openEnrollment,
+                                bool allowPublish, bool maturePublish)
+        {
+            Hashtable param = new Hashtable();
+            param["GroupID"] = groupID.ToString();
+            param["Charter"] = charter;
+            param["ShowInList"] = showInList == true ? 1 : 0;
+            param["InsigniaID"] = insigniaID.ToString();
+            param["MembershipFee"] = membershipFee;
+            param["OpenEnrollment"] = openEnrollment == true ? 1 : 0;
+            param["AllowPublish"] = allowPublish == true ? 1 : 0;
+            param["MaturePublish"] = maturePublish == true ? 1 : 0;
+
+            XmlRpcCall(requestingAgentID, "groups.updateGroup", param);
+        }
+
+        public void AddGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID, string name, string description,
+                                 string title, ulong powers)
+        {
+            Hashtable param = new Hashtable();
+            param["GroupID"] = groupID.ToString();
+            param["RoleID"] = roleID.ToString();
+            param["Name"] = name;
+            param["Description"] = description;
+            param["Title"] = title;
+            param["Powers"] = powers.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.addRoleToGroup", param);
+        }
+
+        public void RemoveGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID)
+        {
+            Hashtable param = new Hashtable();
+            param["GroupID"] = groupID.ToString();
+            param["RoleID"] = roleID.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.removeRoleFromGroup", param);
+        }
+
+        public void UpdateGroupRole(UUID requestingAgentID, UUID groupID, UUID roleID, string name, string description,
+                                    string title, ulong powers)
+        {
+            Hashtable param = new Hashtable();
+            param["GroupID"] = groupID.ToString();
+            param["RoleID"] = roleID.ToString();
+            if (name != null)
+            {
+                param["Name"] = name;
+            }
+            if (description != null)
+            {
+                param["Description"] = description;
+            }
+            if (title != null)
+            {
+                param["Title"] = title;
+            }
+            param["Powers"] = powers.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.updateGroupRole", param);
+        }
+
+        public GroupRecord GetGroupRecord(UUID requestingAgentID, UUID GroupID, string GroupName)
+        {
+            Hashtable param = new Hashtable();
+            if (GroupID != UUID.Zero)
+            {
+                param["GroupID"] = GroupID.ToString();
+            }
+            if (!string.IsNullOrEmpty(GroupName))
+            {
+                param["Name"] = GroupName.ToString();
+            }
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroup", param);
+
+            if (respData.Contains("error"))
+            {
+                return null;
+            }
+
+            return GroupProfileHashtableToGroupRecord(respData);
+
+        }
+
+        public GroupProfileData GetMemberGroupProfile(UUID requestingAgentID, UUID GroupID, UUID AgentID)
+        {
+            Hashtable param = new Hashtable();
+            param["GroupID"] = GroupID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroup", param);
+
+            if (respData.Contains("error"))
+            {
+                // GroupProfileData is not nullable
+                return new GroupProfileData();
+            }
+
+            GroupMembershipData MemberInfo = GetAgentGroupMembership(requestingAgentID, AgentID, GroupID);
+            GroupProfileData MemberGroupProfile = GroupProfileHashtableToGroupProfileData(respData);
+
+            MemberGroupProfile.MemberTitle = MemberInfo.GroupTitle;
+            MemberGroupProfile.PowersMask = MemberInfo.GroupPowers;
+
+            return MemberGroupProfile;
+        }
+
+        public void SetAgentActiveGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+            param["GroupID"] = GroupID.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.setAgentActiveGroup", param);
+        }
+
+        public void SetAgentActiveGroupRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+            param["GroupID"] = GroupID.ToString();
+            param["SelectedRoleID"] = RoleID.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.setAgentGroupInfo", param);
+        }
+
+        public void SetAgentGroupInfo(UUID requestingAgentID, UUID AgentID, UUID GroupID, bool AcceptNotices, bool ListInProfile)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+            param["GroupID"] = GroupID.ToString();
+            param["AcceptNotices"] = AcceptNotices ? "1" : "0";
+            param["ListInProfile"] = ListInProfile ? "1" : "0";
+
+            XmlRpcCall(requestingAgentID, "groups.setAgentGroupInfo", param);
+
+        }
+
+        public void AddAgentToGroupInvite(UUID requestingAgentID, UUID inviteID, UUID groupID, UUID roleID, UUID agentID)
+        {
+            Hashtable param = new Hashtable();
+            param["InviteID"] = inviteID.ToString();
+            param["AgentID"] = agentID.ToString();
+            param["RoleID"] = roleID.ToString();
+            param["GroupID"] = groupID.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.addAgentToGroupInvite", param);
+
+        }
+
+        public GroupInviteInfo GetAgentToGroupInvite(UUID requestingAgentID, UUID inviteID)
+        {
+            Hashtable param = new Hashtable();
+            param["InviteID"] = inviteID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentToGroupInvite", param);
+
+            if (respData.Contains("error"))
+            {
+                return null;
+            }
+
+            GroupInviteInfo inviteInfo = new GroupInviteInfo();
+            inviteInfo.InviteID = inviteID;
+            inviteInfo.GroupID = UUID.Parse((string)respData["GroupID"]);
+            inviteInfo.RoleID = UUID.Parse((string)respData["RoleID"]);
+            inviteInfo.AgentID = UUID.Parse((string)respData["AgentID"]);
+
+            return inviteInfo;
+        }
+
+        public void RemoveAgentToGroupInvite(UUID requestingAgentID, UUID inviteID)
+        {
+            Hashtable param = new Hashtable();
+            param["InviteID"] = inviteID.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.removeAgentToGroupInvite", param);
+        }
+
+        public void AddAgentToGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+            param["GroupID"] = GroupID.ToString();
+            param["RoleID"] = RoleID.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.addAgentToGroup", param);
+        }
+
+        public void RemoveAgentFromGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+            param["GroupID"] = GroupID.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.removeAgentFromGroup", param);
+        }
+
+        public void AddAgentToGroupRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+            param["GroupID"] = GroupID.ToString();
+            param["RoleID"] = RoleID.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.addAgentToGroupRole", param);
+        }
+
+        public void RemoveAgentFromGroupRole(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+            param["GroupID"] = GroupID.ToString();
+            param["RoleID"] = RoleID.ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.removeAgentFromGroupRole", param);
+        }
+
+        public List<DirGroupsReplyData> FindGroups(UUID requestingAgentID, string search)
+        {
+            Hashtable param = new Hashtable();
+            param["Search"] = search;
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.findGroups", param);
+
+            List<DirGroupsReplyData> findings = new List<DirGroupsReplyData>();
+
+            if (!respData.Contains("error"))
+            {
+                Hashtable results = (Hashtable)respData["results"];
+                foreach (Hashtable groupFind in results.Values)
+                {
+                    DirGroupsReplyData data = new DirGroupsReplyData();
+                    data.groupID = new UUID((string)groupFind["GroupID"]); ;
+                    data.groupName = (string)groupFind["Name"];
+                    data.members = int.Parse((string)groupFind["Members"]);
+                    // data.searchOrder = order;
+
+                    findings.Add(data);
+                }
+            }
+
+            return findings;
+        }
+
+        public GroupMembershipData GetAgentGroupMembership(UUID requestingAgentID, UUID AgentID, UUID GroupID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+            param["GroupID"] = GroupID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentGroupMembership", param);
+
+            if (respData.Contains("error"))
+            {
+                return null;
+            }
+
+            GroupMembershipData data = HashTableToGroupMembershipData(respData);
+
+            return data;
+        }
+
+        public GroupMembershipData GetAgentActiveMembership(UUID requestingAgentID, UUID AgentID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentActiveMembership", param);
+
+            if (respData.Contains("error"))
+            {
+                return null;
+            }
+
+            return HashTableToGroupMembershipData(respData);
+        }
+
+        public List<GroupMembershipData> GetAgentGroupMemberships(UUID requestingAgentID, UUID AgentID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentGroupMemberships", param);
+
+            List<GroupMembershipData> memberships = new List<GroupMembershipData>();
+
+            if (!respData.Contains("error"))
+            {
+                foreach (object membership in respData.Values)
+                {
+                    memberships.Add(HashTableToGroupMembershipData((Hashtable)membership));
+                }
+            }
+
+            return memberships;
+        }
+
+        public List<GroupRolesData> GetAgentGroupRoles(UUID requestingAgentID, UUID AgentID, UUID GroupID)
+        {
+            Hashtable param = new Hashtable();
+            param["AgentID"] = AgentID.ToString();
+            param["GroupID"] = GroupID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getAgentRoles", param);
+
+            List<GroupRolesData> Roles = new List<GroupRolesData>();
+
+            if (respData.Contains("error"))
+            {
+                return Roles;
+            }
+
+            foreach (Hashtable role in respData.Values)
+            {
+                GroupRolesData data = new GroupRolesData();
+                data.RoleID = new UUID((string)role["RoleID"]);
+                data.Name = (string)role["Name"];
+                data.Description = (string)role["Description"];
+                data.Powers = ulong.Parse((string)role["Powers"]);
+                data.Title = (string)role["Title"];
+
+                Roles.Add(data);
+            }
+
+            return Roles;
+        }
+
+        public List<GroupRolesData> GetGroupRoles(UUID requestingAgentID, UUID GroupID)
+        {
+            Hashtable param = new Hashtable();
+            param["GroupID"] = GroupID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupRoles", param);
+
+            List<GroupRolesData> Roles = new List<GroupRolesData>();
+
+            if (respData.Contains("error"))
+            {
+                return Roles;
+            }
+
+            foreach (Hashtable role in respData.Values)
+            {
+                GroupRolesData data = new GroupRolesData();
+                data.Description = (string)role["Description"];
+                data.Members = int.Parse((string)role["Members"]);
+                data.Name = (string)role["Name"];
+                data.Powers = ulong.Parse((string)role["Powers"]);
+                data.RoleID = new UUID((string)role["RoleID"]);
+                data.Title = (string)role["Title"];
+
+                Roles.Add(data);
+            }
+
+            return Roles;
+        }
+
+        public List<GroupMembersData> GetGroupMembers(UUID requestingAgentID, UUID GroupID)
+        {
+            Hashtable param = new Hashtable();
+            param["GroupID"] = GroupID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupMembers", param);
+
+            List<GroupMembersData> members = new List<GroupMembersData>();
+
+            if (respData.Contains("error"))
+            {
+                return members;
+            }
+
+            foreach (Hashtable membership in respData.Values)
+            {
+                GroupMembersData data = new GroupMembersData();
+
+                data.AcceptNotices = ((string)membership["AcceptNotices"]) == "1";
+                data.AgentID = new UUID((string)membership["AgentID"]);
+                data.Contribution = int.Parse((string)membership["Contribution"]);
+                data.IsOwner = ((string)membership["IsOwner"]) == "1";
+                data.ListInProfile = ((string)membership["ListInProfile"]) == "1";
+                data.AgentPowers = ulong.Parse((string)membership["AgentPowers"]);
+                data.Title = (string)membership["Title"];
+
+                members.Add(data);
+            }
+
+            return members;
+        }
+
+        public List<GroupRoleMembersData> GetGroupRoleMembers(UUID requestingAgentID, UUID GroupID)
+        {
+            Hashtable param = new Hashtable();
+            param["GroupID"] = GroupID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupRoleMembers", param);
+
+            List<GroupRoleMembersData> members = new List<GroupRoleMembersData>();
+
+            if (!respData.Contains("error"))
+            {
+                foreach (Hashtable membership in respData.Values)
+                {
+                    GroupRoleMembersData data = new GroupRoleMembersData();
+
+                    data.MemberID = new UUID((string)membership["AgentID"]);
+                    data.RoleID = new UUID((string)membership["RoleID"]);
+
+                    members.Add(data);
+                }
+            }
+            return members;
+        }
+
+        public List<GroupNoticeData> GetGroupNotices(UUID requestingAgentID, UUID GroupID)
+        {
+            Hashtable param = new Hashtable();
+            param["GroupID"] = GroupID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupNotices", param);
+
+            List<GroupNoticeData> values = new List<GroupNoticeData>();
+
+            if (!respData.Contains("error"))
+            {
+                foreach (Hashtable value in respData.Values)
+                {
+                    GroupNoticeData data = new GroupNoticeData();
+                    data.NoticeID = UUID.Parse((string)value["NoticeID"]);
+                    data.Timestamp = uint.Parse((string)value["Timestamp"]);
+                    data.FromName = (string)value["FromName"];
+                    data.Subject = (string)value["Subject"];
+                    data.HasAttachment = false;
+                    data.AssetType = 0;
+
+                    values.Add(data);
+                }
+            }
+
+            return values;
+        }
+
+        public GroupNoticeInfo GetGroupNotice(UUID requestingAgentID, UUID noticeID)
+        {
+            Hashtable param = new Hashtable();
+            param["NoticeID"] = noticeID.ToString();
+
+            Hashtable respData = XmlRpcCall(requestingAgentID, "groups.getGroupNotice", param);
+
+            if (respData.Contains("error"))
+            {
+                return null;
+            }
+
+            GroupNoticeInfo data = new GroupNoticeInfo();
+            data.GroupID = UUID.Parse((string)respData["GroupID"]);
+            data.Message = (string)respData["Message"];
+            data.BinaryBucket = Utils.HexStringToBytes((string)respData["BinaryBucket"], true);
+            data.noticeData.NoticeID = UUID.Parse((string)respData["NoticeID"]);
+            data.noticeData.Timestamp = uint.Parse((string)respData["Timestamp"]);
+            data.noticeData.FromName = (string)respData["FromName"];
+            data.noticeData.Subject = (string)respData["Subject"];
+            data.noticeData.HasAttachment = false;
+            data.noticeData.AssetType = 0;
+
+            if (data.Message == null)
+            {
+                data.Message = string.Empty;
+            }
+
+            return data;
+        }
+
+        public void AddGroupNotice(UUID requestingAgentID, UUID groupID, UUID noticeID, string fromName, string subject, string message, byte[] binaryBucket)
+        {
+            string binBucket = OpenMetaverse.Utils.BytesToHexString(binaryBucket, "");
+
+            Hashtable param = new Hashtable();
+            param["GroupID"] = groupID.ToString();
+            param["NoticeID"] = noticeID.ToString();
+            param["FromName"] = fromName;
+            param["Subject"] = subject;
+            param["Message"] = message;
+            param["BinaryBucket"] = binBucket;
+            param["TimeStamp"] = ((uint)Util.UnixTimeSinceEpoch()).ToString();
+
+            XmlRpcCall(requestingAgentID, "groups.addGroupNotice", param);
+        }
+
+        #endregion
+
+        #region GroupSessionTracking
+
+        public void ResetAgentGroupChatSessions(UUID agentID)
+        {
+            foreach (List<UUID> agentList in m_groupsAgentsDroppedFromChatSession.Values)
+            {
+                agentList.Remove(agentID);
+            }
+        }
+
+        public bool hasAgentBeenInvitedToGroupChatSession(UUID agentID, UUID groupID)
+        {
+            // If we're  tracking this group, and we can find them in the tracking, then they've been invited
+            return m_groupsAgentsInvitedToChatSession.ContainsKey(groupID)
+                && m_groupsAgentsInvitedToChatSession[groupID].Contains(agentID);
+        }
+
+        public bool hasAgentDroppedGroupChatSession(UUID agentID, UUID groupID)
+        {
+            // If we're tracking drops for this group,
+            // and we find them, well... then they've dropped
+            return m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID)
+                && m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID);
+        }
+
+        public void AgentDroppedFromGroupChatSession(UUID agentID, UUID groupID)
+        {
+            if (m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))
+            {
+                // If not in dropped list, add
+                if (!m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))
+                {
+                    m_groupsAgentsDroppedFromChatSession[groupID].Add(agentID);
+                }
+            }
+        }
+
+        public void AgentInvitedToGroupChatSession(UUID agentID, UUID groupID)
+        {
+            // Add Session Status if it doesn't exist for this session
+            CreateGroupChatSessionTracking(groupID);
+
+            // If nessesary, remove from dropped list
+            if (m_groupsAgentsDroppedFromChatSession[groupID].Contains(agentID))
+            {
+                m_groupsAgentsDroppedFromChatSession[groupID].Remove(agentID);
+            }
+        }
+
+        private void CreateGroupChatSessionTracking(UUID groupID)
+        {
+            if (!m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))
+            {
+                m_groupsAgentsDroppedFromChatSession.Add(groupID, new List<UUID>());
+                m_groupsAgentsInvitedToChatSession.Add(groupID, new List<UUID>());
+            }
+
+        }
+        #endregion
+
+        #region XmlRpcHashtableMarshalling
+        private GroupProfileData GroupProfileHashtableToGroupProfileData(Hashtable groupProfile)
+        {
+            GroupProfileData group = new GroupProfileData();
+            group.GroupID = UUID.Parse((string)groupProfile["GroupID"]);
+            group.Name = (string)groupProfile["Name"];
+
+            if (groupProfile["Charter"] != null)
+            {
+                group.Charter = (string)groupProfile["Charter"];
+            }
+
+            group.ShowInList = ((string)groupProfile["ShowInList"]) == "1";
+            group.InsigniaID = UUID.Parse((string)groupProfile["InsigniaID"]);
+            group.MembershipFee = int.Parse((string)groupProfile["MembershipFee"]);
+            group.OpenEnrollment = ((string)groupProfile["OpenEnrollment"]) == "1";
+            group.AllowPublish = ((string)groupProfile["AllowPublish"]) == "1";
+            group.MaturePublish = ((string)groupProfile["MaturePublish"]) == "1";
+            group.FounderID = UUID.Parse((string)groupProfile["FounderID"]);
+            group.OwnerRole = UUID.Parse((string)groupProfile["OwnerRoleID"]);
+
+            group.GroupMembershipCount = int.Parse((string)groupProfile["GroupMembershipCount"]);
+            group.GroupRolesCount = int.Parse((string)groupProfile["GroupRolesCount"]);
+
+            return group;
+        }
+
+        private GroupRecord GroupProfileHashtableToGroupRecord(Hashtable groupProfile)
+        {
+            GroupRecord group = new GroupRecord();
+            group.GroupID = UUID.Parse((string)groupProfile["GroupID"]);
+            group.GroupName = groupProfile["Name"].ToString();
+            if (groupProfile["Charter"] != null)
+            {
+                group.Charter = (string)groupProfile["Charter"];
+            }
+            group.ShowInList = ((string)groupProfile["ShowInList"]) == "1";
+            group.GroupPicture = UUID.Parse((string)groupProfile["InsigniaID"]);
+            group.MembershipFee = int.Parse((string)groupProfile["MembershipFee"]);
+            group.OpenEnrollment = ((string)groupProfile["OpenEnrollment"]) == "1";
+            group.AllowPublish = ((string)groupProfile["AllowPublish"]) == "1";
+            group.MaturePublish = ((string)groupProfile["MaturePublish"]) == "1";
+            group.FounderID = UUID.Parse((string)groupProfile["FounderID"]);
+            group.OwnerRoleID = UUID.Parse((string)groupProfile["OwnerRoleID"]);
+
+            return group;
+        }
+
+        private static GroupMembershipData HashTableToGroupMembershipData(Hashtable respData)
+        {
+            GroupMembershipData data = new GroupMembershipData();
+            data.AcceptNotices = ((string)respData["AcceptNotices"] == "1");
+            data.Contribution = int.Parse((string)respData["Contribution"]);
+            data.ListInProfile = ((string)respData["ListInProfile"] == "1");
+
+            data.ActiveRole = new UUID((string)respData["SelectedRoleID"]);
+            data.GroupTitle = (string)respData["Title"];
+
+            data.GroupPowers = ulong.Parse((string)respData["GroupPowers"]);
+
+            // Is this group the agent's active group
+
+            data.GroupID = new UUID((string)respData["GroupID"]);
+
+            UUID ActiveGroup = new UUID((string)respData["ActiveGroupID"]);
+            data.Active = data.GroupID.Equals(ActiveGroup);
+
+            data.AllowPublish = ((string)respData["AllowPublish"] == "1");
+            if (respData["Charter"] != null)
+            {
+                data.Charter = (string)respData["Charter"];
+            }
+            data.FounderID = new UUID((string)respData["FounderID"]);
+            data.GroupID = new UUID((string)respData["GroupID"]);
+            data.GroupName = (string)respData["GroupName"];
+            data.GroupPicture = new UUID((string)respData["InsigniaID"]);
+            data.MaturePublish = ((string)respData["MaturePublish"] == "1");
+            data.MembershipFee = int.Parse((string)respData["MembershipFee"]);
+            data.OpenEnrollment = ((string)respData["OpenEnrollment"] == "1");
+            data.ShowInList = ((string)respData["ShowInList"] == "1");
+
+            return data;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Encapsulate the XmlRpc call to standardize security and error handling.
+        /// </summary>
+        private Hashtable XmlRpcCall(UUID requestingAgentID, string function, Hashtable param)
+        {
+            XmlRpcResponse resp = null;
+            string CacheKey = null;
+
+            // Only bother with the cache if it isn't disabled.
+            if (m_cacheTimeout > 0)
+            {
+                if (!function.StartsWith("groups.get"))
+                {
+                    // Any and all updates cause the cache to clear
+                    m_memoryCache.Clear();
+                }
+                else
+                {
+                    StringBuilder sb = new StringBuilder(requestingAgentID + function);
+                    foreach (object key in param.Keys)
+                    {
+                        if (param[key] != null)
+                        {
+                            sb.AppendFormat(",{0}:{1}", key.ToString(), param[key].ToString());
+                        }
+                    }
+
+                    CacheKey = sb.ToString();
+                    m_memoryCache.TryGetValue(CacheKey, out resp);
+                }
+            }
+
+            if (resp == null)
+            {
+                if (m_debugEnabled)
+                    m_log.DebugFormat("[XMLRPC-GROUPS-CONNECTOR]: Cache miss for key {0}", CacheKey);
+
+                string UserService;
+                UUID SessionID;
+                GetClientGroupRequestID(requestingAgentID, out UserService, out SessionID);
+
+                param.Add("RequestingAgentID", requestingAgentID.ToString());
+                param.Add("RequestingAgentUserService", UserService);
+                param.Add("RequestingSessionID", SessionID.ToString());
+                param.Add("ReadKey", m_groupReadKey);
+                param.Add("WriteKey", m_groupWriteKey);
+
+                IList parameters = new ArrayList();
+                parameters.Add(param);
+
+                ConfigurableKeepAliveXmlRpcRequest req;
+                req = new ConfigurableKeepAliveXmlRpcRequest(function, parameters, m_disableKeepAlive);
+
+                try
+                {
+                    resp = req.Send(m_groupsServerURI, 10000);
+
+                    if ((m_cacheTimeout > 0) && (CacheKey != null))
+                    {
+                        m_memoryCache.AddOrUpdate(CacheKey, resp, TimeSpan.FromSeconds(m_cacheTimeout));
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat(
+                        "[XMLRPC-GROUPS-CONNECTOR]: An error has occured while attempting to access the XmlRpcGroups server method {0} at {1}",
+                        function, m_groupsServerURI);
+
+                    m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: {0}{1}", e.Message, e.StackTrace);
+
+                    foreach (string ResponseLine in req.RequestResponse.Split(new string[] { Environment.NewLine }, StringSplitOptions.None))
+                    {
+                        m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: {0} ", ResponseLine);
+                    }
+
+                    foreach (string key in param.Keys)
+                    {
+                        m_log.WarnFormat("[XMLRPC-GROUPS-CONNECTOR]: {0} :: {1}", key, param[key].ToString());
+                    }
+
+                    Hashtable respData = new Hashtable();
+                    respData.Add("error", e.ToString());
+                    return respData;
+                }
+            }
+
+            if (resp.Value is Hashtable)
+            {
+                Hashtable respData = (Hashtable)resp.Value;
+                if (respData.Contains("error") && !respData.Contains("succeed"))
+                {
+                    LogRespDataToConsoleError(requestingAgentID, function, param, respData);
+                }
+
+                return respData;
+            }
+
+            m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: The XmlRpc server returned a {1} instead of a hashtable for {0}", function, resp.Value.GetType().ToString());
+
+            if (resp.Value is ArrayList)
+            {
+                ArrayList al = (ArrayList)resp.Value;
+                m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: Contains {0} elements", al.Count);
+
+                foreach (object o in al)
+                {
+                    m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: {0} :: {1}", o.GetType().ToString(), o.ToString());
+                }
+            }
+            else
+            {
+                m_log.ErrorFormat("[XMLRPC-GROUPS-CONNECTOR]: Function returned: {0}", resp.Value.ToString());
+            }
+
+            Hashtable error = new Hashtable();
+            error.Add("error", "invalid return value");
+            return error;
+        }
+
+        private void LogRespDataToConsoleError(UUID requestingAgentID, string function, Hashtable param, Hashtable respData)
+        {
+            m_log.ErrorFormat(
+                "[XMLRPC-GROUPS-CONNECTOR]: Error when calling {0} for {1} with params {2}.  Response params are {3}", 
+                function, requestingAgentID, Util.PrettyFormatToSingleLine(param), Util.PrettyFormatToSingleLine(respData));
+        }
+
+        /// <summary>
+        /// Group Request Tokens are an attempt to allow the groups service to authenticate
+        /// requests.
+        /// TODO: This broke after the big grid refactor, either find a better way, or discard this
+        /// </summary>
+        /// <param name="client"></param>
+        /// <returns></returns>
+        private void GetClientGroupRequestID(UUID AgentID, out string UserServiceURL, out UUID SessionID)
+        {
+            UserServiceURL = "";
+            SessionID = UUID.Zero;
+
+
+            // Need to rework this based on changes to User Services
+            /*
+            UserAccount userAccount = m_accountService.GetUserAccount(UUID.Zero,AgentID);
+            if (userAccount == null)
+            {
+                // This should be impossible.  If I've been passed a reference to a client
+                // that client should be registered with the UserService.  So something
+                // is horribly wrong somewhere.
+
+                m_log.WarnFormat("[GROUPS]: Could not find a UserServiceURL for {0}", AgentID);
+
+            }
+            else if (userProfile is ForeignUserProfileData)
+            {
+                // They aren't from around here
+                ForeignUserProfileData fupd = (ForeignUserProfileData)userProfile;
+                UserServiceURL = fupd.UserServerURI;
+                SessionID = fupd.CurrentAgent.SessionID;
+
+            }
+            else
+            {
+                // They're a local user, use this:
+                UserServiceURL = m_commManager.NetworkServersInfo.UserURL;
+                SessionID = userProfile.CurrentAgent.SessionID;
+            }
+            */
+        }
+
+    }
+}
+
+namespace Nwc.XmlRpc
+{
+    using System;
+    using System.Collections;
+    using System.IO;
+    using System.Xml;
+    using System.Net;
+    using System.Text;
+    using System.Reflection;
+
+    /// <summary>Class supporting the request side of an XML-RPC transaction.</summary>
+    public class ConfigurableKeepAliveXmlRpcRequest : XmlRpcRequest
+    {
+        private XmlRpcRequestSerializer _serializer = new XmlRpcRequestSerializer();
+        private XmlRpcResponseDeserializer _deserializer = new XmlRpcResponseDeserializer();
+        private bool _disableKeepAlive = true;
+
+        public string RequestResponse = String.Empty;
+
+        /// <summary>Instantiate an <c>XmlRpcRequest</c> for a specified method and parameters.</summary>
+        /// <param name="methodName"><c>String</c> designating the <i>object.method</i> on the server the request
+        /// should be directed to.</param>
+        /// <param name="parameters"><c>ArrayList</c> of XML-RPC type parameters to invoke the request with.</param>
+        public ConfigurableKeepAliveXmlRpcRequest(String methodName, IList parameters, bool disableKeepAlive)
+        {
+            MethodName = methodName;
+            _params = parameters;
+            _disableKeepAlive = disableKeepAlive;
+        }
+
+        /// <summary>Send the request to the server.</summary>
+        /// <param name="url"><c>String</c> The url of the XML-RPC server.</param>
+        /// <returns><c>XmlRpcResponse</c> The response generated.</returns>
+        public XmlRpcResponse Send(String url)
+        {
+            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
+            if (request == null)
+                throw new XmlRpcException(XmlRpcErrorCodes.TRANSPORT_ERROR,
+                              XmlRpcErrorCodes.TRANSPORT_ERROR_MSG + ": Could not create request with " + url);
+            request.Method = "POST";
+            request.ContentType = "text/xml";
+            request.AllowWriteStreamBuffering = true;
+            request.KeepAlive = !_disableKeepAlive;
+
+            using (Stream stream = request.GetRequestStream())
+            {
+                using (XmlTextWriter xml = new XmlTextWriter(stream, Encoding.ASCII))
+                {
+                    _serializer.Serialize(xml, this);
+                    xml.Flush();
+                }            
+            }
+
+            XmlRpcResponse resp;
+
+            using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
+            {
+                using (Stream s = response.GetResponseStream())
+                {
+                    using (StreamReader input = new StreamReader(s))
+                    {
+                        string inputXml = input.ReadToEnd();
+
+                        try
+                        {
+                            resp = (XmlRpcResponse)_deserializer.Deserialize(inputXml);
+                        }
+                        catch (Exception e)
+                        {
+                            RequestResponse = inputXml;
+                            throw e;
+                        }
+                    }
+                }
+            }
+
+            return resp;
+        }
+    }
+}