10 files changed, 437 insertions, 234 deletions

diff --git a/OpenSim/Addons/Groups/GroupsExtendedData.cs b/OpenSim/Addons/Groups/GroupsExtendedData.cs
index 6f4db28..1632aee 100644
--- a/OpenSim/Addons/Groups/GroupsExtendedData.cs
+++ b/OpenSim/Addons/Groups/GroupsExtendedData.cs
@@ -504,6 +504,30 @@ namespace OpenSim.Groups
 
             return notice;
         }
+
+        public static Dictionary<string, object> DirGroupsReplyData(DirGroupsReplyData g)
+        {
+            Dictionary<string, object> dict = new Dictionary<string, object>();
+
+            dict["GroupID"] = g.groupID;
+            dict["Name"] = g.groupName;
+            dict["NMembers"] = g.members;
+            dict["SearchOrder"] = g.searchOrder;
+
+            return dict;
+        }
+
+        public static DirGroupsReplyData DirGroupsReplyData(Dictionary<string, object> dict)
+        {
+            DirGroupsReplyData g;
+
+            g.groupID = new UUID(dict["GroupID"].ToString());
+            g.groupName = dict["Name"].ToString();
+            Int32.TryParse(dict["NMembers"].ToString(), out g.members);
+            float.TryParse(dict["SearchOrder"].ToString(), out g.searchOrder);
+
+            return g;
+        }
     }
 
 }
diff --git a/OpenSim/Addons/Groups/GroupsMessagingModule.cs b/OpenSim/Addons/Groups/GroupsMessagingModule.cs
index d172d48..5de1fb4 100644
--- a/OpenSim/Addons/Groups/GroupsMessagingModule.cs
+++ b/OpenSim/Addons/Groups/GroupsMessagingModule.cs
@@ -39,6 +39,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
 using PresenceInfo = OpenSim.Services.Interfaces.PresenceInfo;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 
 namespace OpenSim.Groups
 {
@@ -51,7 +52,7 @@ namespace OpenSim.Groups
         private IPresenceService m_presenceService;
 
         private IMessageTransferModule m_msgTransferModule = null;
-
+        private IUserManagement m_UserManagement = null;
         private IGroupsServicesConnector m_groupData = null;
 
         // Config Options
@@ -79,6 +80,10 @@ namespace OpenSim.Groups
 
         private int m_usersOnlineCacheExpirySeconds = 20;
 
+        private Dictionary<UUID, List<string>> m_groupsAgentsDroppedFromChatSession = new Dictionary<UUID, List<string>>();
+        private Dictionary<UUID, List<string>> m_groupsAgentsInvitedToChatSession = new Dictionary<UUID, List<string>>();
+
+
         #region Region Module interfaceBase Members
 
         public void Initialise(IConfigSource config)
@@ -124,10 +129,12 @@ namespace OpenSim.Groups
             m_sceneList.Add(scene);
 
             scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;
+            scene.EventManager.OnMakeChildAgent += OnMakeChildAgent;
             scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
             scene.EventManager.OnClientLogin += OnClientLogin;
         }
-        
+
         public void RegionLoaded(Scene scene)
         {
             if (!m_groupMessagingEnabled)
@@ -155,6 +162,17 @@ namespace OpenSim.Groups
                 return;
             }
 
+            m_UserManagement = scene.RequestModuleInterface<IUserManagement>();
+
+            // No groups module, no groups messaging
+            if (m_UserManagement == null)
+            {
+                m_log.Error("[Groups.Messaging]: Could not get IUserManagement, GroupsMessagingModule is now disabled.");
+                RemoveRegion(scene);
+                return;
+            }
+
+
             if (m_presenceService == null)
                 m_presenceService = scene.PresenceService;
 
@@ -227,87 +245,106 @@ namespace OpenSim.Groups
         
         public void SendMessageToGroup(GridInstantMessage im, UUID groupID)
         {
-            List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers(new UUID(im.fromAgentID).ToString(), groupID);
+            UUID fromAgentID = new UUID(im.fromAgentID);
+            List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers("all", groupID);
             int groupMembersCount = groupMembers.Count;
+            PresenceInfo[] onlineAgents = null;
 
-            if (m_messageOnlineAgentsOnly)
-            {
-                string[] t1 = groupMembers.ConvertAll<string>(gmd => gmd.AgentID.ToString()).ToArray();
+            // In V2 we always only send to online members.
+            // Sending to offline members is not an option.
+            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);
-                }
+            // 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).
+            if (!m_usersOnlineCache.TryGetValue(groupID, out onlineAgents))
+            {
+                onlineAgents = m_presenceService.GetAgents(t1);
+                m_usersOnlineCache.Add(groupID, onlineAgents, m_usersOnlineCacheExpirySeconds);
+            }
 
-                HashSet<string> onlineAgentsUuidSet = new HashSet<string>();
-                Array.ForEach<PresenceInfo>(onlineAgents, pi => onlineAgentsUuidSet.Add(pi.UserID));
+            HashSet<string> onlineAgentsUuidSet = new HashSet<string>();
+            Array.ForEach<PresenceInfo>(onlineAgents, pi => onlineAgentsUuidSet.Add(pi.UserID));
 
-                groupMembers = groupMembers.Where(gmd => onlineAgentsUuidSet.Contains(gmd.AgentID.ToString())).ToList();
+            groupMembers = groupMembers.Where(gmd => onlineAgentsUuidSet.Contains(gmd.AgentID.ToString())).ToList();
 
-    //            if (m_debugEnabled)
+//            if (m_debugEnabled)
 //                    m_log.DebugFormat(
 //                        "[Groups.Messaging]: SendMessageToGroup called for group {0} with {1} visible members, {2} online",
 //                        groupID, groupMembersCount, groupMembers.Count());
-            }
-            else
+
+            int requestStartTick = Environment.TickCount;
+
+            im.imSessionID = groupID.Guid;
+            im.fromGroup = true;
+            IClientAPI thisClient = GetActiveClient(fromAgentID);
+            if (thisClient != null)
             {
-                if (m_debugEnabled)
-                    m_log.DebugFormat(
-                        "[Groups.Messaging]: SendMessageToGroup called for group {0} with {1} visible members",
-                        groupID, groupMembers.Count);
+                im.RegionID = thisClient.Scene.RegionInfo.RegionID.Guid;
             }
 
-            int requestStartTick = Environment.TickCount;
+            // Send to self first of all
+            im.toAgentID = im.fromAgentID;
+            im.fromGroup = true;
+            ProcessMessageFromGroupSession(im);
 
+            List<UUID> regions = new List<UUID>();
+            List<UUID> clientsAlreadySent = new List<UUID>();
+
+            // Then send to everybody else
             foreach (GroupMembersData member in groupMembers)
             {
-                if (m_groupData.hasAgentDroppedGroupChatSession(member.AgentID.ToString(), groupID))
+                if (member.AgentID.Guid == im.fromAgentID)
+                    continue;
+
+                if (hasAgentDroppedGroupChatSession(member.AgentID.ToString(), 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 = groupID.Guid;
-                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;
+                im.toAgentID = member.AgentID.Guid;
 
                 IClientAPI client = GetActiveClient(member.AgentID);
                 if (client == null)
                 {
                     // If they're not local, forward across the grid
+                    // BUT do it only once per region, please! Sim would be even better!
                     if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Delivering to {0} via Grid", member.AgentID);
-                    m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { });
+
+                    bool reallySend = true;
+                    if (onlineAgents != null)
+                    {
+                        PresenceInfo presence = onlineAgents.First(p => p.UserID == member.AgentID.ToString());
+                        if (regions.Contains(presence.RegionID))
+                            reallySend = false;
+                        else
+                            regions.Add(presence.RegionID);
+                    }
+
+                    if (reallySend)
+                    {
+                        // We have to create a new IM structure because the transfer module
+                        // uses async send
+                        GridInstantMessage msg = new GridInstantMessage(im, true);
+                        m_msgTransferModule.SendInstantMessage(msg, delegate(bool success) { });
+                    }
                 }
                 else
                 {
                     // Deliver locally, directly
                     if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Passing to ProcessMessageFromGroupSession to deliver to {0} locally", client.Name);
-                    ProcessMessageFromGroupSession(msg);
+
+                    if (clientsAlreadySent.Contains(member.AgentID))
+                        continue;
+                    clientsAlreadySent.Add(member.AgentID);
+
+                    ProcessMessageFromGroupSession(im);
                 }
             }
 
-            // Temporary for assessing how long it still takes to send messages to large online groups.
-            if (m_messageOnlineAgentsOnly)
+            if (m_debugEnabled)
                 m_log.DebugFormat(
                     "[Groups.Messaging]: SendMessageToGroup for group {0} with {1} visible members, {2} online took {3}ms",
                     groupID, groupMembersCount, groupMembers.Count(), Environment.TickCount - requestStartTick);
@@ -324,9 +361,20 @@ namespace OpenSim.Groups
         {
             if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: OnInstantMessage registered for {0}", client.Name);
 
-            client.OnInstantMessage += OnInstantMessage;
+            ResetAgentGroupChatSessions(client.AgentId.ToString());
         }
 
+        void OnMakeRootAgent(ScenePresence sp)
+        {
+            sp.ControllingClient.OnInstantMessage += OnInstantMessage;
+        }
+
+        void OnMakeChildAgent(ScenePresence sp)
+        {
+            sp.ControllingClient.OnInstantMessage -= OnInstantMessage;
+        }
+
+
         private void OnGridInstantMessage(GridInstantMessage msg)
         {
             // The instant message module will only deliver messages of dialog types:
@@ -335,21 +383,97 @@ namespace OpenSim.Groups
             // Any other message type will not be delivered to a client by the 
             // Instant Message Module
 
-
+            UUID regionID = new UUID(msg.RegionID);
             if (m_debugEnabled)
             {
-                m_log.DebugFormat("[Groups.Messaging]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+                m_log.DebugFormat("[Groups.Messaging]: {0} called, IM from region {1}", 
+                    System.Reflection.MethodBase.GetCurrentMethod().Name, regionID);
 
                 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)))
+            if ((msg.fromGroup == true) && (msg.dialog == (byte)InstantMessageDialog.SessionSend))
             {
-                ProcessMessageFromGroupSession(msg);
+                // We have to redistribute the message across all members of the group who are here
+                // on this sim
+
+                UUID GroupID = new UUID(msg.imSessionID);
+
+                Scene aScene = m_sceneList[0];
+                GridRegion regionOfOrigin = aScene.GridService.GetRegionByUUID(aScene.RegionInfo.ScopeID, regionID);
+
+                List<GroupMembersData> groupMembers = m_groupData.GetGroupMembers("all", GroupID);
+                List<UUID> alreadySeen = new List<UUID>();
+
+                //if (m_debugEnabled)
+                //    foreach (GroupMembersData m in groupMembers)
+                //        m_log.DebugFormat("[Groups.Messaging]: member {0}", m.AgentID);
+
+                foreach (Scene s in m_sceneList)
+                {
+                    s.ForEachScenePresence(sp =>
+                        {
+                            // We need this, because we are searching through all
+                            // SPs, both root and children
+                            if (alreadySeen.Contains(sp.UUID))
+                            {
+                                if (m_debugEnabled)
+                                    m_log.DebugFormat("[Groups.Messaging]: skipping agent {0} because we've already seen it", sp.UUID);
+                                return;
+                            }
+                            alreadySeen.Add(sp.UUID);
+
+                            GroupMembersData m = groupMembers.Find(gmd =>
+                                {
+                                    return gmd.AgentID == sp.UUID;
+                                });
+                            if (m.AgentID == UUID.Zero)
+                            {
+                                if (m_debugEnabled)
+                                    m_log.DebugFormat("[Groups.Messaging]: skipping agent {0} because he is not a member of the group", sp.UUID);
+                                return;
+                            }
+
+                            // Check if the user has an agent in the region where
+                            // the IM came from, and if so, skip it, because the IM
+                            // was already sent via that agent
+                            if (regionOfOrigin != null)
+                            {
+                                AgentCircuitData aCircuit = s.AuthenticateHandler.GetAgentCircuitData(sp.UUID);
+                                if (aCircuit != null)
+                                {
+                                    if (aCircuit.ChildrenCapSeeds.Keys.Contains(regionOfOrigin.RegionHandle))
+                                    {
+                                        if (m_debugEnabled)
+                                            m_log.DebugFormat("[Groups.Messaging]: skipping agent {0} because he has an agent in region of origin", sp.UUID);
+                                        return;
+                                    }
+                                    else                                
+                                    {
+                                        if (m_debugEnabled)
+                                            m_log.DebugFormat("[Groups.Messaging]: not skipping agent {0}", sp.UUID);
+                                    }
+                                }
+                            }
+
+                            UUID AgentID = sp.UUID;
+                            msg.toAgentID = AgentID.Guid;
+
+                            if (!hasAgentDroppedGroupChatSession(AgentID.ToString(), GroupID))
+                            {
+                                if (!hasAgentBeenInvitedToGroupChatSession(AgentID.ToString(), GroupID))
+                                    AddAgentToSession(AgentID, GroupID, msg);
+                                else
+                                {
+                                    if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Passing to ProcessMessageFromGroupSession to deliver to {0} locally", sp.Name);
+
+                                    ProcessMessageFromGroupSession(msg);
+                                }
+                            }
+                        });
+                        
+                }
             }
         }
 
@@ -359,82 +483,40 @@ namespace OpenSim.Groups
 
             UUID AgentID = new UUID(msg.fromAgentID);
             UUID GroupID = new UUID(msg.imSessionID);
+            UUID toAgentID = new UUID(msg.toAgentID);
 
             switch (msg.dialog)
             {
                 case (byte)InstantMessageDialog.SessionAdd:
-                    m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
                     break;
 
                 case (byte)InstantMessageDialog.SessionDrop:
-                    m_groupData.AgentDroppedFromGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentDroppedFromGroupChatSession(AgentID.ToString(), GroupID);
                     break;
 
                 case (byte)InstantMessageDialog.SessionSend:
-                    if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID.ToString(), GroupID)
-                        && !m_groupData.hasAgentBeenInvitedToGroupChatSession(AgentID.ToString(), GroupID)
-                        )
+                    // User hasn't dropped, so they're in the session, 
+                    // maybe we should deliver it.
+                    IClientAPI client = GetActiveClient(new UUID(msg.toAgentID));
+                    if (client != null)
                     {
-                        // Agent not in session and hasn't dropped from session
-                        // Add them to the session for now, and Invite them
-                        m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                        // Deliver locally, directly
+                        if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Delivering to {0} locally", client.Name);
 
-                        UUID toAgentID = new UUID(msg.toAgentID);
-                        IClientAPI activeClient = GetActiveClient(toAgentID);
-                        if (activeClient != null)
+                        if (!hasAgentDroppedGroupChatSession(toAgentID.ToString(), GroupID))
                         {
-                            GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero.ToString(), 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 = activeClient.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
-                                    , OpenMetaverse.Utils.StringToBytes(groupInfo.GroupName)
-                                    );
-
-                                eq.ChatterBoxSessionAgentListUpdates(
-                                    new UUID(GroupID)
-                                    , new UUID(msg.fromAgentID)
-                                    , new UUID(msg.toAgentID)
-                                    , false //canVoiceChat
-                                    , false //isModerator
-                                    , false //text mute
-                                    );
-                            }
+                            if (!hasAgentBeenInvitedToGroupChatSession(toAgentID.ToString(), GroupID))
+                                // This actually sends the message too, so no need to resend it
+                                // with client.SendInstantMessage
+                                AddAgentToSession(toAgentID, GroupID, msg);
+                            else
+                                client.SendInstantMessage(msg);
                         }
                     }
-                    else if (!m_groupData.hasAgentDroppedGroupChatSession(AgentID.ToString(), GroupID))
+                    else
                     {
-                        // User hasn't dropped, so they're in the session, 
-                        // maybe we should deliver it.
-                        IClientAPI client = GetActiveClient(new UUID(msg.toAgentID));
-                        if (client != null)
-                        {
-                            // Deliver locally, directly
-                            if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Delivering to {0} locally", client.Name);
-                            client.SendInstantMessage(msg);
-                        }
-                        else
-                        {
-                            m_log.WarnFormat("[Groups.Messaging]: Received a message over the grid for a client that isn't here: {0}", msg.toAgentID);
-                        }
+                        m_log.WarnFormat("[Groups.Messaging]: Received a message over the grid for a client that isn't here: {0}", msg.toAgentID);
                     }
                     break;
 
@@ -444,6 +526,53 @@ namespace OpenSim.Groups
             }
         }
 
+        private void AddAgentToSession(UUID AgentID, UUID GroupID, GridInstantMessage msg)
+        {
+            // Agent not in session and hasn't dropped from session
+            // Add them to the session for now, and Invite them
+            AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+
+            IClientAPI activeClient = GetActiveClient(AgentID);
+            if (activeClient != null)
+            {
+                GroupRecord groupInfo = m_groupData.GetGroupRecord(UUID.Zero.ToString(), 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 = activeClient.Scene.RequestModuleInterface<IEventQueue>();
+                    eq.ChatterboxInvitation(
+                        GroupID
+                        , groupInfo.GroupName
+                        , new UUID(msg.fromAgentID)
+                        , msg.message
+                        , AgentID
+                        , msg.fromAgentName
+                        , msg.dialog
+                        , msg.timestamp
+                        , msg.offline == 1
+                        , (int)msg.ParentEstateID
+                        , msg.Position
+                        , 1
+                        , new UUID(msg.imSessionID)
+                        , msg.fromGroup
+                        , OpenMetaverse.Utils.StringToBytes(groupInfo.GroupName)
+                        );
+
+                    eq.ChatterBoxSessionAgentListUpdates(
+                        new UUID(GroupID)
+                        , AgentID
+                        , new UUID(msg.toAgentID)
+                        , false //canVoiceChat
+                        , false //isModerator
+                        , false //text mute
+                        );
+                }
+            }
+        }
+
         #endregion
 
 
@@ -469,7 +598,7 @@ namespace OpenSim.Groups
     
                 if (groupInfo != null)
                 {
-                    m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
 
                     ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, GroupID);
 
@@ -495,7 +624,7 @@ namespace OpenSim.Groups
                     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.ToString(), GroupID);
+                AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
 
                 SendMessageToGroup(im, GroupID);
             }
@@ -566,12 +695,12 @@ namespace OpenSim.Groups
                 {
                     if (!sp.IsChildAgent)
                     {
-                        if (m_debugEnabled) m_log.WarnFormat("[Groups.Messaging]: Found root agent for client : {0}", sp.ControllingClient.Name);
+                        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.WarnFormat("[Groups.Messaging]: Found child agent for client : {0}", sp.ControllingClient.Name);
+                        if (m_debugEnabled) m_log.DebugFormat("[Groups.Messaging]: Found child agent for client : {0}", sp.ControllingClient.Name);
                         child = sp.ControllingClient;
                     }
                 }
@@ -590,5 +719,71 @@ namespace OpenSim.Groups
         }
 
         #endregion
+
+        #region GroupSessionTracking
+
+        public void ResetAgentGroupChatSessions(string agentID)
+        {
+            foreach (List<string> agentList in m_groupsAgentsDroppedFromChatSession.Values)
+                agentList.Remove(agentID);
+
+            foreach (List<string> agentList in m_groupsAgentsInvitedToChatSession.Values)
+                agentList.Remove(agentID);
+        }
+
+        public bool hasAgentBeenInvitedToGroupChatSession(string 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(string 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(string 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(string 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);
+            }
+
+            // Add to invited
+            if (!m_groupsAgentsInvitedToChatSession[groupID].Contains(agentID))
+                m_groupsAgentsInvitedToChatSession[groupID].Add(agentID);
+        }
+
+        private void CreateGroupChatSessionTracking(UUID groupID)
+        {
+            if (!m_groupsAgentsDroppedFromChatSession.ContainsKey(groupID))
+            {
+                m_groupsAgentsDroppedFromChatSession.Add(groupID, new List<string>());
+                m_groupsAgentsInvitedToChatSession.Add(groupID, new List<string>());
+            }
+
+        }
+        #endregion
+
     }
 }
diff --git a/OpenSim/Addons/Groups/GroupsModule.cs b/OpenSim/Addons/Groups/GroupsModule.cs
index 69d03a9..826fcbf 100644
--- a/OpenSim/Addons/Groups/GroupsModule.cs
+++ b/OpenSim/Addons/Groups/GroupsModule.cs
@@ -141,6 +141,8 @@ namespace OpenSim.Groups
             if (m_debugEnabled) m_log.DebugFormat("[Groups]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
             scene.EventManager.OnNewClient += OnNewClient;
+            scene.EventManager.OnMakeRootAgent += OnMakeRoot;
+            scene.EventManager.OnMakeChildAgent += OnMakeChild;
             scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
             // The InstantMessageModule itself doesn't do this, 
             // so lets see if things explode if we don't do it
@@ -194,6 +196,8 @@ namespace OpenSim.Groups
             if (m_debugEnabled) m_log.DebugFormat("[Groups]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
             scene.EventManager.OnNewClient -= OnNewClient;
+            scene.EventManager.OnMakeRootAgent -= OnMakeRoot;
+            scene.EventManager.OnMakeChildAgent -= OnMakeChild;
             scene.EventManager.OnIncomingInstantMessage -= OnGridInstantMessage;
 
             lock (m_sceneList)
@@ -232,16 +236,29 @@ namespace OpenSim.Groups
         {
             if (m_debugEnabled) m_log.DebugFormat("[Groups]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            client.OnUUIDGroupNameRequest += HandleUUIDGroupNameRequest;
             client.OnAgentDataUpdateRequest += OnAgentDataUpdateRequest;
-            client.OnDirFindQuery += OnDirFindQuery;
             client.OnRequestAvatarProperties += OnRequestAvatarProperties;
+        }
+
+        private void OnMakeRoot(ScenePresence sp)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[Groups]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
+            sp.ControllingClient.OnUUIDGroupNameRequest += HandleUUIDGroupNameRequest;
             // Used for Notices and Group Invites/Accept/Reject
-            client.OnInstantMessage += OnInstantMessage;
+            sp.ControllingClient.OnInstantMessage += OnInstantMessage;
 
             // Send client their groups information.
-            SendAgentGroupDataUpdate(client, client.AgentId);
+            SendAgentGroupDataUpdate(sp.ControllingClient, sp.UUID);
+        }
+
+        private void OnMakeChild(ScenePresence sp)
+        {
+            if (m_debugEnabled) m_log.DebugFormat("[Groups]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
+
+            sp.ControllingClient.OnUUIDGroupNameRequest -= HandleUUIDGroupNameRequest;
+            // Used for Notices and Group Invites/Accept/Reject
+            sp.ControllingClient.OnInstantMessage -= OnInstantMessage;
         }
 
         private void OnRequestAvatarProperties(IClientAPI remoteClient, UUID avatarID)
@@ -287,21 +304,6 @@ namespace OpenSim.Groups
         }
         */
 
-        void OnDirFindQuery(IClientAPI remoteClient, UUID queryID, string queryText, uint queryFlags, int queryStart)
-        {
-            if (((DirFindFlags)queryFlags & DirFindFlags.Groups) == DirFindFlags.Groups)
-            {
-                if (m_debugEnabled) 
-                    m_log.DebugFormat(
-                        "[Groups]: {0} called with queryText({1}) queryFlags({2}) queryStart({3})", 
-                        System.Reflection.MethodBase.GetCurrentMethod().Name, queryText, (DirFindFlags)queryFlags, queryStart);
-
-                // TODO: This currently ignores pretty much all the query flags including Mature and sort order
-                remoteClient.SendDirGroupsReply(queryID, m_groupData.FindGroups(GetRequestingAgentIDStr(remoteClient), queryText).ToArray());
-            }
-            
-        }
-
         private void OnAgentDataUpdateRequest(IClientAPI remoteClient, UUID dataForAgentID, UUID sessionID)
         {
             if (m_debugEnabled) m_log.DebugFormat("[Groups]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
@@ -907,23 +909,7 @@ namespace OpenSim.Groups
         {
             if (m_debugEnabled) m_log.DebugFormat("[Groups]: {0} called for notice {1}", System.Reflection.MethodBase.GetCurrentMethod().Name, groupNoticeID);
 
-            //GroupRecord groupInfo = m_groupData.GetGroupRecord(GetRequestingAgentID(remoteClient), data.GroupID, null);
-
             GridInstantMessage msg = CreateGroupNoticeIM(remoteClient.AgentId, groupNoticeID, (byte)InstantMessageDialog.GroupNoticeRequested);
-            //GridInstantMessage msg = new GridInstantMessage();
-            //msg.imSessionID = UUID.Zero.Guid;
-            //msg.fromAgentID = data.GroupID.Guid;
-            //msg.toAgentID = GetRequestingAgentID(remoteClient).Guid;
-            //msg.timestamp = (uint)Util.UnixTimeSinceEpoch();
-            //msg.fromAgentName = "Group Notice : " + groupInfo == null ? "Unknown" : groupInfo.GroupName;
-            //msg.message = data.noticeData.Subject + "|" + data.Message;
-            //msg.dialog = (byte)OpenMetaverse.InstantMessageDialog.GroupNoticeRequested;
-            //msg.fromGroup = true;
-            //msg.offline = (byte)0;
-            //msg.ParentEstateID = 0;
-            //msg.Position = Vector3.Zero;
-            //msg.RegionID = UUID.Zero.Guid;
-            //msg.binaryBucket = data.BinaryBucket;
 
             OutgoingInstantMessage(msg, GetRequestingAgentID(remoteClient));
         }
@@ -1189,6 +1175,11 @@ namespace OpenSim.Groups
             }
         }
 
+        public List<DirGroupsReplyData> FindGroups(IClientAPI remoteClient, string query)
+        {
+            return m_groupData.FindGroups(GetRequestingAgentIDStr(remoteClient), query);
+        }
+
         #endregion
 
         #region Client/Update Tools
diff --git a/OpenSim/Addons/Groups/Hypergrid/GroupsServiceHGConnectorModule.cs b/OpenSim/Addons/Groups/Hypergrid/GroupsServiceHGConnectorModule.cs
index c3c759e..daa0728 100644
--- a/OpenSim/Addons/Groups/Hypergrid/GroupsServiceHGConnectorModule.cs
+++ b/OpenSim/Addons/Groups/Hypergrid/GroupsServiceHGConnectorModule.cs
@@ -590,28 +590,6 @@ namespace OpenSim.Groups
             return m_LocalGroupsConnector.GetGroupNotices(AgentUUI(RequestingAgentID), GroupID);
         }
 
-        public void ResetAgentGroupChatSessions(string agentID)
-        {
-        }
-
-        public bool hasAgentBeenInvitedToGroupChatSession(string agentID, UUID groupID)
-        {
-            return false;
-        }
-
-        public bool hasAgentDroppedGroupChatSession(string agentID, UUID groupID)
-        {
-            return false;
-        }
-
-        public void AgentDroppedFromGroupChatSession(string agentID, UUID groupID)
-        {
-        }
-
-        public void AgentInvitedToGroupChatSession(string agentID, UUID groupID)
-        {
-        }
-
         #endregion
 
         #region hypergrid groups
diff --git a/OpenSim/Addons/Groups/IGroupsServicesConnector.cs b/OpenSim/Addons/Groups/IGroupsServicesConnector.cs
index 73deb7a..a09b59e 100644
--- a/OpenSim/Addons/Groups/IGroupsServicesConnector.cs
+++ b/OpenSim/Addons/Groups/IGroupsServicesConnector.cs
@@ -92,12 +92,6 @@ namespace OpenSim.Groups
         GroupNoticeInfo GetGroupNotice(string RequestingAgentID, UUID noticeID);
         List<ExtendedGroupNoticeData> GetGroupNotices(string RequestingAgentID, UUID GroupID);
 
-        void ResetAgentGroupChatSessions(string agentID);
-        bool hasAgentBeenInvitedToGroupChatSession(string agentID, UUID groupID);
-        bool hasAgentDroppedGroupChatSession(string agentID, UUID groupID);
-        void AgentDroppedFromGroupChatSession(string agentID, UUID groupID);
-        void AgentInvitedToGroupChatSession(string agentID, UUID groupID);
-
     }
 
     public class GroupInviteInfo
diff --git a/OpenSim/Addons/Groups/Local/GroupsServiceLocalConnectorModule.cs b/OpenSim/Addons/Groups/Local/GroupsServiceLocalConnectorModule.cs
index 905bc91..564dec4 100644
--- a/OpenSim/Addons/Groups/Local/GroupsServiceLocalConnectorModule.cs
+++ b/OpenSim/Addons/Groups/Local/GroupsServiceLocalConnectorModule.cs
@@ -320,28 +320,6 @@ namespace OpenSim.Groups
             return m_GroupsService.GetGroupNotices(RequestingAgentID, GroupID);
         }
 
-        public void ResetAgentGroupChatSessions(string agentID)
-        {
-        }
-
-        public bool hasAgentBeenInvitedToGroupChatSession(string agentID, UUID groupID)
-        {
-            return false;
-        }
-
-        public bool hasAgentDroppedGroupChatSession(string agentID, UUID groupID)
-        {
-            return false;
-        }
-
-        public void AgentDroppedFromGroupChatSession(string agentID, UUID groupID)
-        {
-        }
-
-        public void AgentInvitedToGroupChatSession(string agentID, UUID groupID)
-        {
-        }
-
         #endregion
     }
 }
diff --git a/OpenSim/Addons/Groups/Remote/GroupsServiceRemoteConnector.cs b/OpenSim/Addons/Groups/Remote/GroupsServiceRemoteConnector.cs
index 04328c9..9a3e125 100644
--- a/OpenSim/Addons/Groups/Remote/GroupsServiceRemoteConnector.cs
+++ b/OpenSim/Addons/Groups/Remote/GroupsServiceRemoteConnector.cs
@@ -133,6 +133,36 @@ namespace OpenSim.Groups
             return GroupsDataUtils.GroupRecord((Dictionary<string, object>)ret["RESULT"]);
         }
 
+        public List<DirGroupsReplyData> FindGroups(string RequestingAgentID, string query)
+        {
+            List<DirGroupsReplyData> hits = new List<DirGroupsReplyData>();
+            if (string.IsNullOrEmpty(query))
+                return hits;
+
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["Query"] = query;
+            sendData["RequestingAgentID"] = RequestingAgentID;
+
+            Dictionary<string, object> ret = MakeRequest("FINDGROUPS", sendData);
+
+            if (ret == null)
+                return hits;
+
+            if (!ret.ContainsKey("RESULT"))
+                return hits;
+
+            if (ret["RESULT"].ToString() == "NULL")
+                return hits;
+
+            foreach (object v in ((Dictionary<string, object>)ret["RESULT"]).Values)
+            {
+                DirGroupsReplyData m = GroupsDataUtils.DirGroupsReplyData((Dictionary<string, object>)v);
+                hits.Add(m);
+            }
+
+            return hits;
+        }
+
         public GroupMembershipData AddAgentToGroup(string RequestingAgentID, string AgentID, UUID GroupID, UUID RoleID, string token, out string reason)
         {
             reason = string.Empty;
diff --git a/OpenSim/Addons/Groups/Remote/GroupsServiceRemoteConnectorModule.cs b/OpenSim/Addons/Groups/Remote/GroupsServiceRemoteConnectorModule.cs
index f1cf66c..d3de0e8 100644
--- a/OpenSim/Addons/Groups/Remote/GroupsServiceRemoteConnectorModule.cs
+++ b/OpenSim/Addons/Groups/Remote/GroupsServiceRemoteConnectorModule.cs
@@ -199,7 +199,7 @@ namespace OpenSim.Groups
         public List<DirGroupsReplyData> FindGroups(string RequestingAgentID, string search)
         {
             // TODO!
-            return new List<DirGroupsReplyData>();
+            return m_GroupsService.FindGroups(RequestingAgentID, search);
         }
 
         public bool AddAgentToGroup(string RequestingAgentID, string AgentID, UUID GroupID, UUID RoleID, string token, out string reason)
@@ -406,28 +406,6 @@ namespace OpenSim.Groups
             });
         }
 
-        public void ResetAgentGroupChatSessions(string agentID)
-        {
-        }
-
-        public bool hasAgentBeenInvitedToGroupChatSession(string agentID, UUID groupID)
-        {
-            return false;
-        }
-
-        public bool hasAgentDroppedGroupChatSession(string agentID, UUID groupID)
-        {
-            return false;
-        }
-
-        public void AgentDroppedFromGroupChatSession(string agentID, UUID groupID)
-        {
-        }
-
-        public void AgentInvitedToGroupChatSession(string agentID, UUID groupID)
-        {
-        }
-
         #endregion
     }
 
diff --git a/OpenSim/Addons/Groups/Remote/GroupsServiceRobustConnector.cs b/OpenSim/Addons/Groups/Remote/GroupsServiceRobustConnector.cs
index 106c6c4..249d974 100644
--- a/OpenSim/Addons/Groups/Remote/GroupsServiceRobustConnector.cs
+++ b/OpenSim/Addons/Groups/Remote/GroupsServiceRobustConnector.cs
@@ -133,6 +133,8 @@ namespace OpenSim.Groups
                         return HandleAddNotice(request);
                     case "GETNOTICES":
                         return HandleGetNotices(request);
+                    case "FINDGROUPS":
+                        return HandleFindGroups(request);
                 }
                 m_log.DebugFormat("[GROUPS HANDLER]: unknown method request: {0}", method);
             }
@@ -740,6 +742,32 @@ namespace OpenSim.Groups
             return Util.UTF8NoBomEncoding.GetBytes(xmlString);
         }
 
+        byte[] HandleFindGroups(Dictionary<string, object> request)
+        {
+            Dictionary<string, object> result = new Dictionary<string, object>();
+
+            if (!request.ContainsKey("RequestingAgentID") || !request.ContainsKey("Query"))
+                NullResult(result, "Bad network data");
+
+            List<DirGroupsReplyData> hits = m_GroupsService.FindGroups(request["RequestingAgentID"].ToString(), request["Query"].ToString());
+
+            if (hits == null || (hits != null && hits.Count == 0))
+                NullResult(result, "No hits");
+            else
+            {
+                Dictionary<string, object> dict = new Dictionary<string, object>();
+                int i = 0;
+                foreach (DirGroupsReplyData n in hits)
+                    dict["n-" + i++] = GroupsDataUtils.DirGroupsReplyData(n);
+
+                result["RESULT"] = dict;
+            }
+
+
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            return Util.UTF8NoBomEncoding.GetBytes(xmlString);
+        }
+
 
         #region Helpers
 
diff --git a/OpenSim/Addons/Groups/Service/GroupsService.cs b/OpenSim/Addons/Groups/Service/GroupsService.cs
index a2ef13a..294b89a 100644
--- a/OpenSim/Addons/Groups/Service/GroupsService.cs
+++ b/OpenSim/Addons/Groups/Service/GroupsService.cs
@@ -255,13 +255,20 @@ namespace OpenSim.Groups
                 return members;
             List<RoleData> rolesList = new List<RoleData>(roles);
 
-            // Is the requester a member of the group?
-            bool isInGroup = false;
-            if (m_Database.RetrieveMember(GroupID, RequestingAgentID) != null)
-                isInGroup = true;
+            // Check visibility? 
+            // When we don't want to check visibility, we pass it "all" as the requestingAgentID
+            bool checkVisibility = !RequestingAgentID.Equals("all");
+            m_log.DebugFormat("[ZZZ]: AgentID is {0}. checkVisibility is {1}", RequestingAgentID, checkVisibility);
+            if (checkVisibility)
+            {
+                // Is the requester a member of the group?
+                bool isInGroup = false;
+                if (m_Database.RetrieveMember(GroupID, RequestingAgentID) != null)
+                    isInGroup = true;
 
-            if (!isInGroup) // reduce the roles to the visible ones
-                rolesList = rolesList.FindAll(r => (UInt64.Parse(r.Data["Powers"]) & (ulong)GroupPowers.MemberVisible) != 0);
+                if (!isInGroup) // reduce the roles to the visible ones
+                    rolesList = rolesList.FindAll(r => (UInt64.Parse(r.Data["Powers"]) & (ulong)GroupPowers.MemberVisible) != 0);
+            }
 
             MembershipData[] datas = m_Database.RetrieveMembers(GroupID);
             if (datas == null || (datas != null && datas.Length == 0))