53 files changed, 954 insertions, 472 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..be59c62 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,107 @@ 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(UUID.Zero.ToString(), 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 (clientsAlreadySent.Contains(member.AgentID))
+                    continue;
+                clientsAlreadySent.Add(member.AgentID);
+
+                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);
+
+                    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 +362,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 +384,91 @@ 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(UUID.Zero.ToString(), GroupID);
+
+                //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 =>
+                        {
+                            // If we got this via grid messaging, it's because the caller thinks
+                            // that the root agent is here. We should only send the IM to root agents.
+                            if (sp.IsChildAgent)
+                                return;
+
+                            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 +478,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 +521,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 +593,7 @@ namespace OpenSim.Groups
     
                 if (groupInfo != null)
                 {
-                    m_groupData.AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
+                    AgentInvitedToGroupChatSession(AgentID.ToString(), GroupID);
 
                     ChatterBoxSessionStartReplyViaCaps(remoteClient, groupInfo.GroupName, GroupID);
 
@@ -495,7 +619,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 +690,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 +714,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 f805d69..b0493fa 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);
@@ -347,7 +349,7 @@ namespace OpenSim.Groups
         {
             if (m_debugEnabled) m_log.DebugFormat("[Groups]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
-            m_log.DebugFormat("[Groups]: IM From {0} to {1} msg {2} type {3}", im.fromAgentID, im.toAgentID, im.message, (InstantMessageDialog)im.dialog);
+            //m_log.DebugFormat("[Groups]: IM From {0} to {1} msg {2} type {3}", im.fromAgentID, im.toAgentID, im.message, (InstantMessageDialog)im.dialog);
             // Group invitations
             if ((im.dialog == (byte)InstantMessageDialog.GroupInvitationAccept) || (im.dialog == (byte)InstantMessageDialog.GroupInvitationDecline))
             {
@@ -465,12 +467,12 @@ namespace OpenSim.Groups
                         }
 
                         // Send notice out to everyone that wants notices
-                        // Build notice IIM
-                        GridInstantMessage msg = CreateGroupNoticeIM(UUID.Zero, NoticeID, (byte)OpenMetaverse.InstantMessageDialog.GroupNotice);
                         foreach (GroupMembersData member in m_groupData.GetGroupMembers(GetRequestingAgentIDStr(remoteClient), GroupID))
                         {
                             if (member.AcceptNotices)
                             {
+                                // Build notice IIM, one of reach, because the sending may be async
+                                GridInstantMessage msg = CreateGroupNoticeIM(UUID.Zero, NoticeID, (byte)OpenMetaverse.InstantMessageDialog.GroupNotice);
                                 msg.toAgentID = member.AgentID.Guid;
                                 OutgoingInstantMessage(msg, member.AgentID);
                             }
@@ -485,7 +487,7 @@ namespace OpenSim.Groups
                     return;
 
                 //// 16 bytes are the UUID. Maybe.
-                UUID folderID = new UUID(im.binaryBucket, 0);
+//                UUID folderID = new UUID(im.binaryBucket, 0);
                 UUID noticeID = new UUID(im.imSessionID);
 
                 GroupNoticeInfo notice = m_groupData.GetGroupNotice(remoteClient.AgentId.ToString(), noticeID);
@@ -766,14 +768,17 @@ namespace OpenSim.Groups
                     remoteClient.SendCreateGroupReply(UUID.Zero, false, "Insufficient funds to create a group.");
                     return UUID.Zero;
                 }
-                money.ApplyCharge(remoteClient.AgentId, money.GroupCreationCharge, MoneyTransactionType.GroupCreate);
             }
+
             string reason = string.Empty;
             UUID groupID = m_groupData.CreateGroup(remoteClient.AgentId, name, charter, showInList, insigniaID, membershipFee, openEnrollment, 
                 allowPublish, maturePublish, remoteClient.AgentId, out reason);
 
             if (groupID != UUID.Zero)
             {
+                if (money != null)
+                    money.ApplyCharge(remoteClient.AgentId, money.GroupCreationCharge, MoneyTransactionType.GroupCreate);
+
                 remoteClient.SendCreateGroupReply(groupID, true, "Group created successfullly");
 
                 // Update the founder with new group information.
@@ -904,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));
         }
@@ -1002,6 +991,10 @@ namespace OpenSim.Groups
 
                 // Should this send updates to everyone in the group?
                 SendAgentGroupDataUpdate(remoteClient, GetRequestingAgentID(remoteClient));
+
+                if (reason != string.Empty)
+                    // A warning
+                    remoteClient.SendAlertMessage("Warning: " + reason);
             }
             else
                 remoteClient.SendJoinGroupReply(groupID, false);
@@ -1186,6 +1179,11 @@ namespace OpenSim.Groups
             }
         }
 
+        public List<DirGroupsReplyData> FindGroups(IClientAPI remoteClient, string query)
+        {
+            return m_groupData.FindGroups(GetRequestingAgentIDStr(remoteClient), query);
+        }
+
         #endregion
 
         #region Client/Update Tools
@@ -1225,12 +1223,16 @@ namespace OpenSim.Groups
         {
             if (m_debugEnabled) m_log.InfoFormat("[Groups]: {0} called", System.Reflection.MethodBase.GetCurrentMethod().Name);
 
+            // NPCs currently don't have a CAPs structure or event queues.  There is a strong argument for conveying this information
+            // to them anyway since it makes writing server-side bots a lot easier, but for now we don't do anything.
+            if (remoteClient.SceneAgent.PresenceType == PresenceType.Npc)
+                return;
+
             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);
 
@@ -1276,8 +1278,7 @@ namespace OpenSim.Groups
             if (queue != null)
             {
                 queue.Enqueue(queue.BuildEvent("AgentGroupDataUpdate", llDataStruct), GetRequestingAgentID(remoteClient));
-            }
-            
+            }            
         }
 
         private void SendScenePresenceUpdate(UUID AgentID, string Title)
@@ -1339,6 +1340,7 @@ namespace OpenSim.Groups
 
             GroupMembershipData[] membershipArray = GetProfileListedGroupMemberships(remoteClient, dataForAgentID);
             SendGroupMembershipInfoViaCaps(remoteClient, dataForAgentID, membershipArray);
+
             //remoteClient.SendAvatarGroupsReply(dataForAgentID, membershipArray);
             if (remoteClient.AgentId == dataForAgentID)
                 remoteClient.RefreshGroupMembership();
@@ -1399,19 +1401,18 @@ namespace OpenSim.Groups
             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
+            string firstname = "Unknown", lastname = "Unknown";
+            string name = m_UserManagement.GetUserName(dataForAgentID);
+            if (!string.IsNullOrEmpty(name))
             {
-                firstname = "Unknown";
-                lastname = "Unknown";
+                string[] parts = name.Split(new char[] { ' ' });
+                if (parts.Length >= 2)
+                {
+                    firstname = parts[0];
+                    lastname = parts[1];
+                }
             }
-
+            
             remoteClient.SendAgentDataUpdate(dataForAgentID, activeGroupID, firstname,
                     lastname, activeGroupPowers, activeGroupName,
                     activeGroupTitle);
diff --git a/OpenSim/Addons/Groups/Hypergrid/GroupsServiceHGConnectorModule.cs b/OpenSim/Addons/Groups/Hypergrid/GroupsServiceHGConnectorModule.cs
index f670272..4642b2a 100644
--- a/OpenSim/Addons/Groups/Hypergrid/GroupsServiceHGConnectorModule.cs
+++ b/OpenSim/Addons/Groups/Hypergrid/GroupsServiceHGConnectorModule.cs
@@ -186,7 +186,6 @@ namespace OpenSim.Groups
         public UUID CreateGroup(UUID RequestingAgentID, string name, string charter, bool showInList, UUID insigniaID, int membershipFee, bool openEnrollment, 
             bool allowPublish, bool maturePublish, UUID founderID, out string reason)
         {
-            m_log.DebugFormat("[Groups]: Creating group {0}", name);
             reason = string.Empty;
             if (m_UserManagement.IsLocalGridUser(RequestingAgentID))
                 return m_LocalGroupsConnector.CreateGroup(RequestingAgentID, name, charter, showInList, insigniaID, 
@@ -255,7 +254,10 @@ namespace OpenSim.Groups
         {
             string url = string.Empty, gname = string.Empty;
             if (IsLocal(GroupID, out url, out gname))
-                return m_LocalGroupsConnector.GetGroupMembers(AgentUUI(RequestingAgentID), GroupID);
+            {
+                string agentID = AgentUUI(RequestingAgentID);
+                return m_LocalGroupsConnector.GetGroupMembers(agentID, GroupID);
+            }
             else if (!string.IsNullOrEmpty(url))
             {
                 ExtendedGroupMembershipData membership = m_LocalGroupsConnector.GetAgentGroupMembership(RequestingAgentID, RequestingAgentID, GroupID);
@@ -397,17 +399,21 @@ namespace OpenSim.Groups
 
                     if (success)
                     {
+                        // Here we always return true. The user has been added to the local group,
+                        // independent of whether the remote operation succeeds or not
                         url = m_UserManagement.GetUserServerURL(uid, "GroupsServerURI");
                         if (url == string.Empty)
                         {
-                            reason = "User doesn't have a groups server";
-                            return false;
+                            reason = "You don't have an accessible groups server in your home world. You membership to this group in only within this grid.";
+                            return true;
                         }
 
                         GroupsServiceHGConnector c = GetConnector(url);
                         if (c != null)
-                            return c.CreateProxy(AgentUUI(RequestingAgentID), AgentID, token, GroupID, m_LocalGroupsServiceLocation, name, out reason);
+                            c.CreateProxy(AgentUUI(RequestingAgentID), AgentID, token, GroupID, m_LocalGroupsServiceLocation, name, out reason);
+                        return true;
                     }
+                    return false;
                 }
             }
             else if (m_UserManagement.IsLocalGridUser(uid)) // local user
@@ -544,7 +550,6 @@ namespace OpenSim.Groups
                     List<string> urls = new List<string>();
                     foreach (GroupMembersData m in members)
                     {
-                        UUID userID = UUID.Zero;
                         if (!m_UserManagement.IsLocalGridUser(m.AgentID))
                         {
                             string gURL = m_UserManagement.GetUserServerURL(m.AgentID, "GroupsServerURI");
@@ -592,28 +597,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
@@ -685,6 +668,9 @@ namespace OpenSim.Groups
         {
             serviceLocation = string.Empty;
             name = string.Empty;
+            if (groupID.Equals(UUID.Zero))
+                return true;
+
             ExtendedGroupRecord group = m_LocalGroupsConnector.GetGroupRecord(UUID.Zero.ToString(), groupID, string.Empty);
             if (group == null)
             {
diff --git a/OpenSim/Addons/Groups/Hypergrid/HGGroupsServiceRobustConnector.cs b/OpenSim/Addons/Groups/Hypergrid/HGGroupsServiceRobustConnector.cs
index 3584f78..6f58922 100644
--- a/OpenSim/Addons/Groups/Hypergrid/HGGroupsServiceRobustConnector.cs
+++ b/OpenSim/Addons/Groups/Hypergrid/HGGroupsServiceRobustConnector.cs
@@ -47,7 +47,6 @@ namespace OpenSim.Groups
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private HGGroupsService m_GroupsService;
-        private string m_HomeURI = string.Empty;
         private string m_ConfigName = "Groups";
 
         // Called by Robust shell
@@ -209,7 +208,6 @@ namespace OpenSim.Groups
                 UUID groupID = new UUID(request["GroupID"].ToString());
                 string agentID = request["AgentID"].ToString();
                 string token = request["AccessToken"].ToString();
-                string reason = string.Empty;
 
                 m_GroupsService.RemoveAgentFromGroup(agentID, agentID, groupID, token);
             }
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..161ca0c 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;
@@ -226,6 +256,7 @@ namespace OpenSim.Groups
             Dictionary<string, object> sendData = new Dictionary<string, object>();
             sendData["GroupID"] = GroupID.ToString();
             sendData["RequestingAgentID"] = RequestingAgentID;
+
             Dictionary<string, object> ret = MakeRequest("GETGROUPMEMBERS", sendData);
 
             if (ret == null)
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 f991d01..7e55d3c 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);
             }
@@ -170,11 +172,16 @@ namespace OpenSim.Groups
 
                 }
 
-                grec = m_GroupsService.GetGroupRecord(RequestingAgentID, grec.GroupID);
-                if (grec == null)
-                    NullResult(result, "Internal Error");
+                if (grec.GroupID != UUID.Zero)
+                {
+                    grec = m_GroupsService.GetGroupRecord(RequestingAgentID, grec.GroupID);
+                    if (grec == null)
+                        NullResult(result, "Internal Error");
+                    else
+                        result["RESULT"] = GroupsDataUtils.GroupRecord(grec);
+                }
                 else
-                    result["RESULT"] = GroupsDataUtils.GroupRecord(grec);
+                    NullResult(result, reason);
             }
 
             string xmlString = ServerUtils.BuildXmlResponse(result);
@@ -264,7 +271,6 @@ namespace OpenSim.Groups
                 UUID groupID = new UUID(request["GroupID"].ToString());
                 string agentID = request["AgentID"].ToString();
                 string requestingAgentID = request["RequestingAgentID"].ToString();
-                string reason = string.Empty;
 
                 m_GroupsService.RemoveAgentFromGroup(requestingAgentID, agentID, groupID);
             }
@@ -495,7 +501,6 @@ namespace OpenSim.Groups
             else
             {
                 string op = request["OP"].ToString();
-                string reason = string.Empty;
 
                 bool success = false;
                 if (op == "ADD")
@@ -563,7 +568,6 @@ namespace OpenSim.Groups
             else
             {
                 string op = request["OP"].ToString();
-                string reason = string.Empty;
 
                 if (op == "GROUP")
                 {
@@ -626,7 +630,6 @@ namespace OpenSim.Groups
             else
             {
                 string op = request["OP"].ToString();
-                string reason = string.Empty;
 
                 if (op == "ADD" && request.ContainsKey("GroupID") && request.ContainsKey("RoleID") && request.ContainsKey("AgentID"))
                 {   
@@ -739,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/RemoteConnectorCacheWrapper.cs b/OpenSim/Addons/Groups/RemoteConnectorCacheWrapper.cs
index e7d38c2..3ac74fc 100644
--- a/OpenSim/Addons/Groups/RemoteConnectorCacheWrapper.cs
+++ b/OpenSim/Addons/Groups/RemoteConnectorCacheWrapper.cs
@@ -53,7 +53,7 @@ namespace OpenSim.Groups
         private ForeignImporter m_ForeignImporter;
 
         private Dictionary<string, bool> m_ActiveRequests = new Dictionary<string, bool>();
-        private const int GROUPS_CACHE_TIMEOUT = 5 * 60; // 5 minutes
+        private const int GROUPS_CACHE_TIMEOUT = 1 * 60; // 1 minutes
 
         // This all important cache cahces objects of different types:
         // group-<GroupID> or group-<Name>          => ExtendedGroupRecord
@@ -209,13 +209,10 @@ namespace OpenSim.Groups
         public void SetAgentActiveGroup(string AgentID, GroupMembershipDelegate d)
         {
             GroupMembershipData activeGroup = d();
-            if (activeGroup != null)
-            {
-                string cacheKey = "active-" + AgentID.ToString();
-                lock (m_Cache)
-                    if (m_Cache.Contains(cacheKey))
-                        m_Cache.AddOrUpdate(cacheKey, activeGroup, GROUPS_CACHE_TIMEOUT);
-            }
+            string cacheKey = "active-" + AgentID.ToString();
+            lock (m_Cache)
+                if (m_Cache.Contains(cacheKey))
+                    m_Cache.AddOrUpdate(cacheKey, activeGroup, GROUPS_CACHE_TIMEOUT);
         }
 
         public ExtendedGroupMembershipData GetAgentActiveMembership(string AgentID, GroupMembershipDelegate d)
diff --git a/OpenSim/Addons/Groups/Service/GroupsService.cs b/OpenSim/Addons/Groups/Service/GroupsService.cs
index 0668870..037ef59 100644
--- a/OpenSim/Addons/Groups/Service/GroupsService.cs
+++ b/OpenSim/Addons/Groups/Service/GroupsService.cs
@@ -130,6 +130,13 @@ namespace OpenSim.Groups
         {
             reason = string.Empty;
 
+            // Check if the group already exists
+            if (m_Database.RetrieveGroup(name) != null)
+            {
+                reason = "A group with that name already exists";
+                return UUID.Zero;
+            }
+
             // Create the group
             GroupData data = new GroupData();
             data.GroupID = UUID.Random();
@@ -248,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(UUID.Zero.ToString());
 
-            if (!isInGroup) // reduce the roles to the visible ones
-                rolesList = rolesList.FindAll(r => (UInt64.Parse(r.Data["Powers"]) & (ulong)GroupPowers.MemberVisible) != 0);
+            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);
+            }
 
             MembershipData[] datas = m_Database.RetrieveMembers(GroupID);
             if (datas == null || (datas != null && datas.Length == 0))
@@ -723,12 +737,12 @@ namespace OpenSim.Groups
 
         #region Actions without permission checks
 
-        private void _AddAgentToGroup(string RequestingAgentID, string AgentID, UUID GroupID, UUID RoleID)
+        protected void _AddAgentToGroup(string RequestingAgentID, string AgentID, UUID GroupID, UUID RoleID)
         {
             _AddAgentToGroup(RequestingAgentID, AgentID, GroupID, RoleID, string.Empty);
         }
 
-        public void _RemoveAgentFromGroup(string RequestingAgentID, string AgentID, UUID GroupID)
+        protected void _RemoveAgentFromGroup(string RequestingAgentID, string AgentID, UUID GroupID)
         {
             // 1. Delete membership
             m_Database.DeleteMember(GroupID, AgentID);
@@ -780,7 +794,7 @@ namespace OpenSim.Groups
 
         }
 
-        private bool _AddOrUpdateGroupRole(string RequestingAgentID, UUID groupID, UUID roleID, string name, string description, string title, ulong powers, bool add)
+        protected bool _AddOrUpdateGroupRole(string RequestingAgentID, UUID groupID, UUID roleID, string name, string description, string title, ulong powers, bool add)
         {
             RoleData data = m_Database.RetrieveRole(groupID, roleID);
 
@@ -810,12 +824,12 @@ namespace OpenSim.Groups
             return m_Database.StoreRole(data);
         }
 
-        private void _RemoveGroupRole(UUID groupID, UUID roleID)
+        protected void _RemoveGroupRole(UUID groupID, UUID roleID)
         {
             m_Database.DeleteRole(groupID, roleID);
         }
 
-        private void _AddAgentToGroupRole(string RequestingAgentID, string AgentID, UUID GroupID, UUID RoleID)
+        protected void _AddAgentToGroupRole(string RequestingAgentID, string AgentID, UUID GroupID, UUID RoleID)
         {
             RoleMembershipData data = m_Database.RetrieveRoleMember(GroupID, RoleID, AgentID);
             if (data != null)
@@ -840,7 +854,7 @@ namespace OpenSim.Groups
 
         }
 
-        private List<GroupRolesData> _GetGroupRoles(UUID groupID)
+        protected List<GroupRolesData> _GetGroupRoles(UUID groupID)
         {
             List<GroupRolesData> roles = new List<GroupRolesData>();
 
@@ -865,7 +879,7 @@ namespace OpenSim.Groups
             return roles;
         }
 
-        private List<ExtendedGroupRoleMembersData> _GetGroupRoleMembers(UUID GroupID, bool isInGroup)
+        protected List<ExtendedGroupRoleMembersData> _GetGroupRoleMembers(UUID GroupID, bool isInGroup)
         {
             List<ExtendedGroupRoleMembersData> rmembers = new List<ExtendedGroupRoleMembersData>();
 
diff --git a/OpenSim/Data/MySQL/MySQLSimulationData.cs b/OpenSim/Data/MySQL/MySQLSimulationData.cs
index 5320543..537ec85 100644
--- a/OpenSim/Data/MySQL/MySQLSimulationData.cs
+++ b/OpenSim/Data/MySQL/MySQLSimulationData.cs
@@ -458,8 +458,6 @@ namespace OpenSim.Data.MySQL
                 if (prim.ParentUUID == UUID.Zero)
                 {
                     objects[prim.UUID] = new SceneObjectGroup(prim);
-                    if (prim.KeyframeMotion != null)
-                        prim.KeyframeMotion.UpdateSceneObject(objects[prim.UUID]);
                 }
             }
 
diff --git a/OpenSim/Data/SQLite/SQLiteSimulationData.cs b/OpenSim/Data/SQLite/SQLiteSimulationData.cs
index 99a6598..76f717d 100644
--- a/OpenSim/Data/SQLite/SQLiteSimulationData.cs
+++ b/OpenSim/Data/SQLite/SQLiteSimulationData.cs
@@ -732,9 +732,12 @@ namespace OpenSim.Data.SQLite
                             }
 
                             SceneObjectGroup group = new SceneObjectGroup(prim);
+                            
                             createdObjects.Add(group.UUID, group);
                             retvals.Add(group);
                             LoadItems(prim);
+
+                           
                         }
                     }
                     catch (Exception e)
diff --git a/OpenSim/Framework/GridInstantMessage.cs b/OpenSim/Framework/GridInstantMessage.cs
index 6ae0488..da3690c 100644
--- a/OpenSim/Framework/GridInstantMessage.cs
+++ b/OpenSim/Framework/GridInstantMessage.cs
@@ -53,6 +53,24 @@ namespace OpenSim.Framework
             binaryBucket = new byte[0];
         }
 
+        public GridInstantMessage(GridInstantMessage im, bool addTimestamp)
+        {
+            fromAgentID = im.fromAgentID;
+            fromAgentName = im.fromAgentName;
+            toAgentID = im.toAgentID;
+            dialog = im.dialog;
+            fromGroup = im.fromGroup;
+            message = im.message;
+            imSessionID = im.imSessionID;
+            offline = im.offline;
+            Position = im.Position;
+            binaryBucket = im.binaryBucket;
+            RegionID = im.RegionID;
+
+            if (addTimestamp)
+                timestamp = (uint)Util.UnixTimeSinceEpoch();
+        }
+
         public GridInstantMessage(IScene scene, UUID _fromAgentID,
                 string _fromAgentName, UUID _toAgentID,
                 byte _dialog, bool _fromGroup, string _message,
diff --git a/OpenSim/Framework/IMoneyModule.cs b/OpenSim/Framework/IMoneyModule.cs
index 415b7df..55c9613 100644
--- a/OpenSim/Framework/IMoneyModule.cs
+++ b/OpenSim/Framework/IMoneyModule.cs
@@ -33,7 +33,7 @@ namespace OpenSim.Framework
     public interface IMoneyModule
     {
         bool ObjectGiveMoney(UUID objectID, UUID fromID, UUID toID,
-                int amount, UUID txn);
+                int amount, UUID txn, out string reason);
 
         int GetBalance(UUID agentID);
         bool UploadCovered(UUID agentID, int amount);
diff --git a/OpenSim/Framework/NetworkServersInfo.cs b/OpenSim/Framework/NetworkServersInfo.cs
index 4b7d4c7..dfe9695 100644
--- a/OpenSim/Framework/NetworkServersInfo.cs
+++ b/OpenSim/Framework/NetworkServersInfo.cs
@@ -41,6 +41,7 @@ namespace OpenSim.Framework
 
         // "Out of band" managemnt https
         public bool ssl_listener = false;
+        public bool ssl_external = false;
         public uint https_port = 0;
         public string cert_path = String.Empty;
         public string cert_pass = String.Empty;
@@ -64,6 +65,7 @@ namespace OpenSim.Framework
 
             // "Out of band management https"
             ssl_listener = config.Configs["Network"].GetBoolean("https_listener",false);
+            ssl_external = config.Configs["Network"].GetBoolean("https_external",false);
             if( ssl_listener)
             {
                 cert_path = config.Configs["Network"].GetString("cert_path",String.Empty);
diff --git a/OpenSim/Framework/RegionInfo.cs b/OpenSim/Framework/RegionInfo.cs
index 6dde62f..24ec181 100644
--- a/OpenSim/Framework/RegionInfo.cs
+++ b/OpenSim/Framework/RegionInfo.cs
@@ -224,10 +224,12 @@ namespace OpenSim.Framework
         //
         public RegionInfo(string description, XmlNode xmlNode, bool skipConsoleConfig, IConfigSource configSource)
         {
-            // m_configSource = configSource;
-            configMember =
-                new ConfigurationMember(xmlNode, description, loadConfigurationOptions, handleIncomingConfiguration, !skipConsoleConfig);
-            configMember.performConfigurationRetrieve();
+            XmlElement elem = (XmlElement)xmlNode;
+            string name = elem.GetAttribute("Name");
+            string xmlstr = "<Nini>" + xmlNode.OuterXml + "</Nini>";
+            XmlConfigSource source = new XmlConfigSource(XmlReader.Create(new StringReader(xmlstr)));
+            ReadNiniConfig(source, name);
+
             m_serverURI = string.Empty;
         }
 
diff --git a/OpenSim/Framework/RegionLoader/Web/RegionLoaderWebServer.cs b/OpenSim/Framework/RegionLoader/Web/RegionLoaderWebServer.cs
index c7caf6f..65de563 100644
--- a/OpenSim/Framework/RegionLoader/Web/RegionLoaderWebServer.cs
+++ b/OpenSim/Framework/RegionLoader/Web/RegionLoaderWebServer.cs
@@ -93,8 +93,8 @@ namespace OpenSim.Framework.RegionLoader.Web
                                                                                 xmlSource.Length);
                                                         XmlDocument xmlDoc = new XmlDocument();
                                                         xmlDoc.LoadXml(xmlSource);
-                                                        if (xmlDoc.FirstChild.Name == "Regions")
-                                                        {
+                                                        if (xmlDoc.FirstChild.Name == "Nini")
+                            {
                                                                 regionCount = xmlDoc.FirstChild.ChildNodes.Count;
                 
                                                                 if (regionCount > 0)
diff --git a/OpenSim/Region/Application/OpenSimBase.cs b/OpenSim/Region/Application/OpenSimBase.cs
index 7361f50..88bd869 100644
--- a/OpenSim/Region/Application/OpenSimBase.cs
+++ b/OpenSim/Region/Application/OpenSimBase.cs
@@ -195,7 +195,9 @@ namespace OpenSim
 
                 m_securePermissionsLoading = startupConfig.GetBoolean("SecurePermissionsLoading", true);
 
-                string permissionModules = startupConfig.GetString("permissionmodules", "DefaultPermissionsModule");
+                string permissionModules = Util.GetConfigVarFromSections<string>(Config, "permissionmodules",
+                    new string[] { "Startup", "Permissions" }, "DefaultPermissionsModule");
+
                 m_permsModules = new List<string>(permissionModules.Split(','));
             }
 
@@ -392,29 +394,19 @@ namespace OpenSim
             }
             else m_log.Error("[REGIONMODULES]: The new RegionModulesController is missing...");
 
-            // XPTO: Fix this
-//            if (m_securePermissionsLoading)
-//            {
-//                foreach (string s in m_permsModules)
-//                {
-//                    if (!scene.RegionModules.ContainsKey(s))
-//                    {
-//                        bool found = false;
-//                        foreach (IRegionModule m in modules)
-//                        {
-//                            if (m.Name == s)
-//                            {
-//                                found = true;
-//                            }
-//                        }
-//                        if (!found)
-//                        {
-//                            m_log.Fatal("[MODULES]: Required module " + s + " not found.");
-//                            Environment.Exit(0);
-//                        }
-//                    }
-//                }
-//            }
+            if (m_securePermissionsLoading)
+            {
+                foreach (string s in m_permsModules)
+                {
+                    if (!scene.RegionModules.ContainsKey(s))
+                    {
+                        m_log.Fatal("[MODULES]: Required module " + s + " not found.");
+                        Environment.Exit(0);
+                    }
+                }
+
+                m_log.InfoFormat("[SCENE]: Secure permissions loading enabled, modules loaded: {0}", String.Join(" ", m_permsModules.ToArray()));
+            }
 
             scene.SetModuleInterfaces();
 // First Step of bootreport sequence
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
index 59b9585..8241e07 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
@@ -990,13 +990,20 @@ namespace OpenSim.Region.ClientStack.Linden
                         else
                             prim.Name = assetName + "#" + i.ToString();
 
+                        prim.EveryoneMask = 0;
+                        prim.GroupMask = 0;
+
                         if (restrictPerms)
                         {
                             prim.BaseMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
-                            prim.EveryoneMask = 0;
-                            prim.GroupMask = 0;
-                            prim.NextOwnerMask = 0;
                             prim.OwnerMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                            prim.NextOwnerMask = 0;
+                        }
+                        else
+                        {
+                            prim.BaseMask = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                            prim.OwnerMask = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                            prim.NextOwnerMask = (uint)PermissionMask.Transfer;
                         }
 
                         if(istest)
@@ -1099,21 +1106,17 @@ namespace OpenSim.Region.ClientStack.Linden
 
             if (restrictPerms)
             {
-                item.CurrentPermissions
-                    = (uint)(PermissionMask.Move | PermissionMask.Modify);
-
                 item.BasePermissions = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                item.CurrentPermissions = (uint)(PermissionMask.Move | PermissionMask.Modify);
                 item.EveryOnePermissions = 0;
                 item.NextPermissions = 0;
             }
             else
             {
-                item.CurrentPermissions
-                    = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer | PermissionMask.Export);
-
                 item.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                item.CurrentPermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
                 item.EveryOnePermissions = 0;
-                item.NextPermissions = (uint)PermissionMask.All;
+                item.NextPermissions = (uint)PermissionMask.Transfer;
             }
 
             item.CreationDate = Util.UnixTimeSinceEpoch();
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
index a42c96c..0570144 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
@@ -77,6 +77,8 @@ namespace OpenSim.Region.ClientStack.Linden
         private Dictionary<UUID, string> m_capsDict = new Dictionary<UUID, string>();
         private static Thread[] m_workerThreads = null;
 
+        private string m_Url = "localhost";
+
         private static OpenMetaverse.BlockingQueue<aPollRequest> m_queue =
                 new OpenMetaverse.BlockingQueue<aPollRequest>();
 
@@ -86,6 +88,9 @@ namespace OpenSim.Region.ClientStack.Linden
 
         public void Initialise(IConfigSource source)
         {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config != null)
+                m_Url = config.GetString("Cap_GetTexture", "localhost");
         }
 
         public void AddRegion(Scene s)
@@ -343,27 +348,34 @@ namespace OpenSim.Region.ClientStack.Linden
 
         private void RegisterCaps(UUID agentID, Caps caps)
         {
-            string capUrl = "/CAPS/" + UUID.Random() + "/";
-
-            // Register this as a poll service           
-            PollServiceTextureEventArgs args = new PollServiceTextureEventArgs(agentID, m_scene);
-            
-            args.Type = PollServiceEventArgs.EventType.Texture;
-            MainServer.Instance.AddPollServiceHTTPHandler(capUrl, args);
-
-            string hostName = m_scene.RegionInfo.ExternalHostName;
-            uint port = (MainServer.Instance == null) ? 0 : MainServer.Instance.Port;
-            string protocol = "http";
-            
-            if (MainServer.Instance.UseSSL)
+            if (m_Url == "localhost")
+            {
+                string capUrl = "/CAPS/" + UUID.Random() + "/";
+
+                // Register this as a poll service           
+                PollServiceTextureEventArgs args = new PollServiceTextureEventArgs(agentID, m_scene);
+                
+                args.Type = PollServiceEventArgs.EventType.Texture;
+                MainServer.Instance.AddPollServiceHTTPHandler(capUrl, args);
+
+                string hostName = m_scene.RegionInfo.ExternalHostName;
+                uint port = (MainServer.Instance == null) ? 0 : MainServer.Instance.Port;
+                string protocol = "http";
+                
+                if (MainServer.Instance.UseSSL)
+                {
+                    hostName = MainServer.Instance.SSLCommonName;
+                    port = MainServer.Instance.SSLPort;
+                    protocol = "https";
+                }
+                caps.RegisterHandler("GetTexture", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
+                m_pollservices[agentID] = args;
+                m_capsDict[agentID] = capUrl;
+            }
+            else
             {
-                hostName = MainServer.Instance.SSLCommonName;
-                port = MainServer.Instance.SSLPort;
-                protocol = "https";
+                caps.RegisterHandler("GetTexture", m_Url);
             }
-            caps.RegisterHandler("GetTexture", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
-            m_pollservices[agentID] = args;
-            m_capsDict[agentID] = capUrl;
         }
 
         private void DeregisterCaps(UUID agentID, Caps caps)
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index eebb8ae..7c62f90 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -2233,9 +2233,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendAgentDataUpdate(UUID agentid, UUID activegroupid, string firstname, string lastname, ulong grouppowers, string groupname, string grouptitle)
         {
-            m_activeGroupID = activegroupid;
-            m_activeGroupName = groupname;
-            m_activeGroupPowers = grouppowers;
+            if (agentid == AgentId)
+            {
+                m_activeGroupID = activegroupid;
+                m_activeGroupName = groupname;
+                m_activeGroupPowers = grouppowers;
+            }
 
             AgentDataUpdatePacket sendAgentDataUpdate = (AgentDataUpdatePacket)PacketPool.Instance.GetPacket(PacketType.AgentDataUpdate);
             sendAgentDataUpdate.AgentData.ActiveGroupID = activegroupid;
@@ -3933,6 +3936,18 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         part.Shape.ProfileHollow = 27500;
                     }
                 }
+                else if (update.Entity is ScenePresence)
+                {
+                    ScenePresence presence = (ScenePresence)update.Entity;
+
+                    // If ParentUUID is not UUID.Zero and ParentID is 0, this
+                    // avatar is in the process of crossing regions while
+                    // sat on an object. In this state, we don't want any
+                    // updates because they will visually orbit the avatar.
+                    // Update will be forced once crossing is completed anyway.
+                    if (presence.ParentUUID != UUID.Zero && presence.ParentID == 0)
+                        continue;
+                }
 
                 ++updatesThisCall;
 
diff --git a/OpenSim/Region/ClientStack/RegionApplicationBase.cs b/OpenSim/Region/ClientStack/RegionApplicationBase.cs
index 853b72d..287c278 100644
--- a/OpenSim/Region/ClientStack/RegionApplicationBase.cs
+++ b/OpenSim/Region/ClientStack/RegionApplicationBase.cs
@@ -100,13 +100,25 @@ namespace OpenSim.Region.ClientStack
             // "OOB" Server
             if (m_networkServersInfo.ssl_listener)
             {
-                BaseHttpServer server = new BaseHttpServer(
-                    m_networkServersInfo.https_port, m_networkServersInfo.ssl_listener, m_networkServersInfo.cert_path,
-                    m_networkServersInfo.cert_pass);
+                if (!m_networkServersInfo.ssl_external)
+                {
+                    BaseHttpServer server = new BaseHttpServer(
+                        m_networkServersInfo.https_port, m_networkServersInfo.ssl_listener, m_networkServersInfo.cert_path,
+                        m_networkServersInfo.cert_pass);
 
-                m_log.InfoFormat("[REGION SERVER]: Starting HTTPS server on port {0}", server.Port);
-                MainServer.AddHttpServer(server);
-                server.Start();
+                    m_log.InfoFormat("[REGION SERVER]: Starting HTTPS server on port {0}", server.Port);
+                    MainServer.AddHttpServer(server);
+                    server.Start();
+                }
+                else
+                {
+                    BaseHttpServer server = new BaseHttpServer(
+                        m_networkServersInfo.https_port);
+
+                    m_log.InfoFormat("[REGION SERVER]: Starting HTTP server on port {0} for external HTTPS", server.Port);
+                    MainServer.AddHttpServer(server);
+                    server.Start();
+                }
             }
             
             base.StartupSpecific();
@@ -132,4 +144,4 @@ namespace OpenSim.Region.ClientStack
             return physicsPluginManager.GetPhysicsScene(engine, meshEngine, config, osSceneIdentifier);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs b/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
index f2f789b..6495f3f 100644
--- a/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
@@ -302,7 +302,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                     // If we're an NPC then skip all the item checks and manipulations since we don't have an
                     // inventory right now.
                     RezSingleAttachmentFromInventoryInternal(
-                        sp, sp.PresenceType == PresenceType.Npc ? UUID.Zero : attach.ItemID, attach.AssetID, p, true, null);
+                        sp, sp.PresenceType == PresenceType.Npc ? UUID.Zero : attach.ItemID, attach.AssetID, p, true, d);
                 }
                 catch (Exception e)
                 {
diff --git a/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs b/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
index 343cdb5..c52d586 100644
--- a/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Combat/CombatModule.cs
@@ -182,6 +182,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Combat.CombatModule
             try
             {
                 ILandObject obj = avatar.Scene.LandChannel.GetLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
+                if (obj == null)
+                    return;
                 if ((obj.LandData.Flags & (uint)ParcelFlags.AllowDamage) != 0
                     || avatar.Scene.RegionInfo.RegionSettings.AllowDamage)
                 {
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs
index 2d46276..41958b3 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/OfflineMessageModule.cs
@@ -40,6 +40,13 @@ using OpenSim.Region.Framework.Scenes;
 
 namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
 {
+    public struct SendReply
+    {
+        public bool Success;
+        public string Message;
+        public int Disposition;
+    }
+
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "OfflineMessageModule")]
     public class OfflineMessageModule : ISharedRegionModule
     {
@@ -50,6 +57,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         private string m_RestURL = String.Empty;
         IMessageTransferModule m_TransferModule = null;
         private bool m_ForwardOfflineGroupMessages = true;
+        private Dictionary<IClientAPI, List<UUID>> m_repliesSent= new Dictionary<IClientAPI, List<UUID>>();
 
         public void Initialise(IConfigSource config)
         {
@@ -169,6 +177,12 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
         private void OnNewClient(IClientAPI client)
         {
             client.OnRetrieveInstantMessages += RetrieveInstantMessages;
+            client.OnLogout += OnClientLoggedOut;
+        }
+
+        public void OnClientLoggedOut(IClientAPI client)
+        {
+            m_repliesSent.Remove(client);
         }
 
         private void RetrieveInstantMessages(IClientAPI client)
@@ -228,7 +242,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
             if (scene == null)
                 scene = m_SceneList[0];
 
-            bool success = SynchronousRestObjectRequester.MakeRequest<GridInstantMessage, bool>(
+            SendReply reply = SynchronousRestObjectRequester.MakeRequest<GridInstantMessage, SendReply>(
                     "POST", m_RestURL+"/SaveMessage/?scope=" +
                     scene.RegionInfo.ScopeID.ToString(), im);
 
@@ -238,13 +252,38 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                 if (client == null)
                     return;
 
-                client.SendInstantMessage(new GridInstantMessage(
-                        null, new UUID(im.toAgentID),
-                        "System", new UUID(im.fromAgentID),
-                        (byte)InstantMessageDialog.MessageFromAgent,
-                        "User is not logged in. "+
-                        (success ? "Message saved." : "Message not saved"),
-                        false, new Vector3()));
+                if (reply.Message == String.Empty)
+                    reply.Message = "User is not logged in. " + (reply.Success ? "Message saved." : "Message not saved");
+
+                bool sendReply = true;
+
+                switch (reply.Disposition)
+                {
+                case 0: // Normal
+                    break;
+                case 1: // Only once per user
+                    if (m_repliesSent.ContainsKey(client) && m_repliesSent[client].Contains(new UUID(im.toAgentID)))
+                    {
+                        sendReply = false;
+                    }
+                    else
+                    {
+                        if (!m_repliesSent.ContainsKey(client))
+                            m_repliesSent[client] = new List<UUID>();
+                        m_repliesSent[client].Add(new UUID(im.toAgentID));
+                    }
+                    break;
+                }
+
+                if (sendReply)
+                {
+                    client.SendInstantMessage(new GridInstantMessage(
+                            null, new UUID(im.toAgentID),
+                            "System", new UUID(im.fromAgentID),
+                            (byte)InstantMessageDialog.MessageFromAgent,
+                            reply.Message,
+                            false, new Vector3()));
+                }
             }
         }
     }
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
index a606d76..193a27b 100644
--- a/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
@@ -265,7 +265,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                         return UUID.Zero;
                     }
 
-                    remoteClient.SendAgentAlertMessage("Notecard saved", false);
+                    remoteClient.SendAlertMessage("Notecard saved");
                 }
                 else if ((InventoryType)item.InvType == InventoryType.LSL)
                 {
@@ -275,7 +275,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                         return UUID.Zero;
                     }
 
-                    remoteClient.SendAgentAlertMessage("Script saved", false);
+                    remoteClient.SendAlertMessage("Script saved");
                 }
 
                 AssetBase asset =
@@ -799,6 +799,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
             XmlDocument doc = new XmlDocument();
             doc.LoadXml(xmlData);
             XmlElement e = (XmlElement)doc.SelectSingleNode("/CoalescedObject");
+            Vector3 rez_pos;
             if (e == null || attachment) // Single
             {
                 SceneObjectGroup g = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
@@ -820,6 +821,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                     RayStart, RayEnd, RayTargetID, Quaternion.Identity,
                     BypassRayCast, bRayEndIsIntersection, true, g.GetAxisAlignedBoundingBox(out offsetHeight), false);
                 pos.Z += offsetHeight;
+                rez_pos = pos;
             }
             else
             {
@@ -834,6 +836,8 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                         BypassRayCast, bRayEndIsIntersection, true,
                         bbox, false);
 
+                rez_pos = pos;
+
                 pos -= bbox / 2;
 
                 XmlNodeList groups = e.SelectNodes("SceneObjectGroup");
@@ -870,7 +874,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                 primcount += g.PrimCount;
 
             if (!m_Scene.Permissions.CanRezObject(
-                primcount, remoteClient.AgentId, pos)
+                primcount, remoteClient.AgentId, rez_pos)
                 && !attachment)
             {
                 // The client operates in no fail mode. It will
@@ -887,7 +891,7 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                 return null;
             }
 
-            if (item != null && !DoPreRezWhenFromItem(remoteClient, item, objlist, pos, attachment))
+            if (item != null && !DoPreRezWhenFromItem(remoteClient, item, objlist, rez_pos, attachment))
                 return null;
 
             for (int i = 0; i < objlist.Count; i++)
diff --git a/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs b/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
index a5f5749..834fd77 100644
--- a/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
@@ -96,6 +96,10 @@ namespace OpenSim.Region.CoreModules.World.Estate
 
             m_commands = new EstateManagementCommands(this);
             m_commands.Initialise();
+
+            m_regionChangeTimer.Interval = 10000;
+            m_regionChangeTimer.Elapsed += RaiseRegionInfoChange;
+            m_regionChangeTimer.AutoReset = false;
         }
         
         public void RemoveRegion(Scene scene) {}            
diff --git a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
index c307998..4e21724 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
@@ -565,7 +565,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                     requiredPowers = GroupPowers.LandManageBanned;
 
                 if (m_scene.Permissions.CanEditParcelProperties(agentID,
-                        land, requiredPowers))
+                        land, requiredPowers, false))
                 {
                     land.UpdateAccessList(flags, transactionID, sequenceID,
                             sections, entries, remote_client);
@@ -927,7 +927,7 @@ namespace OpenSim.Region.CoreModules.World.Land
 
             //If we are still here, then they are subdividing within one piece of land
             //Check owner
-            if (!m_scene.Permissions.CanEditParcelProperties(attempting_user_id, startLandObject, GroupPowers.LandDivideJoin))
+            if (!m_scene.Permissions.CanEditParcelProperties(attempting_user_id, startLandObject, GroupPowers.LandDivideJoin, true))
             {
                 return;
             }
@@ -996,7 +996,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             {
                 return;
             }
-            if (!m_scene.Permissions.CanEditParcelProperties(attempting_user_id, masterLandObject, GroupPowers.LandDivideJoin))
+            if (!m_scene.Permissions.CanEditParcelProperties(attempting_user_id, masterLandObject, GroupPowers.LandDivideJoin, true))
             {
                 return;
             }
@@ -1727,7 +1727,7 @@ namespace OpenSim.Region.CoreModules.World.Land
 
             if (land == null) return;
 
-            if (!m_scene.Permissions.CanEditParcelProperties(remoteClient.AgentId, land, GroupPowers.LandOptions))
+            if (!m_scene.Permissions.CanEditParcelProperties(remoteClient.AgentId, land, GroupPowers.LandOptions, false))
                 return;
 
             land.LandData.OtherCleanTime = otherCleanTime;
@@ -1827,7 +1827,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             if (targetAvatar.UserLevel == 0)
             {
                 ILandObject land = ((Scene)client.Scene).LandChannel.GetLandObject(targetAvatar.AbsolutePosition.X, targetAvatar.AbsolutePosition.Y);
-                if (!((Scene)client.Scene).Permissions.CanEditParcelProperties(client.AgentId, land, GroupPowers.LandEjectAndFreeze))
+                if (!((Scene)client.Scene).Permissions.CanEditParcelProperties(client.AgentId, land, GroupPowers.LandEjectAndFreeze, true))
                     return;
                 if (flags == 0)
                 {
@@ -1876,7 +1876,7 @@ namespace OpenSim.Region.CoreModules.World.Land
 
             // Check if you even have permission to do this
             ILandObject land = m_scene.LandChannel.GetLandObject(targetAvatar.AbsolutePosition.X, targetAvatar.AbsolutePosition.Y);
-            if (!m_scene.Permissions.CanEditParcelProperties(client.AgentId, land, GroupPowers.LandEjectAndFreeze) &&
+            if (!m_scene.Permissions.CanEditParcelProperties(client.AgentId, land, GroupPowers.LandEjectAndFreeze, true) &&
                 !m_scene.Permissions.IsAdministrator(client.AgentId))
                 return;
 
diff --git a/OpenSim/Region/CoreModules/World/Land/LandObject.cs b/OpenSim/Region/CoreModules/World/Land/LandObject.cs
index 07d00c0..2eafd44 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandObject.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandObject.cs
@@ -286,7 +286,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             // ParcelFlags.ForSaleObjects
             // ParcelFlags.LindenHome
 
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandOptions))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandOptions, false))
             {
                 allowedDelta |= (uint)(ParcelFlags.AllowLandmark |
                         ParcelFlags.AllowTerraform |
@@ -301,7 +301,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                         ParcelFlags.AllowFly);
             }
 
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandSetSale))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandSetSale, true))
             {
                 if (args.AuthBuyerID != newData.AuthBuyerID ||
                     args.SalePrice != newData.SalePrice)
@@ -324,7 +324,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                 allowedDelta |= (uint)ParcelFlags.ForSale;
             }
 
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.FindPlaces))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.FindPlaces, false))
             {
                 newData.Category = args.Category;
 
@@ -333,21 +333,21 @@ namespace OpenSim.Region.CoreModules.World.Land
                         ParcelFlags.MaturePublish) | (uint)(1 << 23);
             }
 
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.LandChangeIdentity))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.LandChangeIdentity, false))
             {
                 newData.Description = args.Desc;
                 newData.Name = args.Name;
                 newData.SnapshotID = args.SnapshotID;
             }
 
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.SetLandingPoint))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.SetLandingPoint, false))
             {
                 newData.LandingType = args.LandingType;
                 newData.UserLocation = args.UserLocation;
                 newData.UserLookAt = args.UserLookAt;
             }
 
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.ChangeMedia))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.ChangeMedia, false))
             {
                 newData.MediaAutoScale = args.MediaAutoScale;
                 newData.MediaID = args.MediaID;
@@ -368,7 +368,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                         ParcelFlags.UseEstateVoiceChan);
             }
 
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.LandManagePasses))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.LandManagePasses, false))
             {
                 newData.PassHours = args.PassHours;
                 newData.PassPrice = args.PassPrice;
@@ -376,25 +376,27 @@ namespace OpenSim.Region.CoreModules.World.Land
                 allowedDelta |= (uint)ParcelFlags.UsePassList;
             }
 
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandManageAllowed))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandManageAllowed, false))
             {
                 allowedDelta |= (uint)(ParcelFlags.UseAccessGroup |
                         ParcelFlags.UseAccessList);
             }
 
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandManageBanned))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandManageBanned, false))
             {
                 allowedDelta |= (uint)(ParcelFlags.UseBanList |
                         ParcelFlags.DenyAnonymous |
                         ParcelFlags.DenyAgeUnverified);
             }
 
-            uint preserve = LandData.Flags & ~allowedDelta;
-            newData.Flags = preserve | (args.ParcelFlags & allowedDelta);
-
-            m_scene.LandChannel.UpdateLandObject(LandData.LocalID, newData);
+            if (allowedDelta != (uint)ParcelFlags.None)
+            {
+                uint preserve = LandData.Flags & ~allowedDelta;
+                newData.Flags = preserve | (args.ParcelFlags & allowedDelta);
 
-            SendLandUpdateToAvatarsOverMe(snap_selection);
+                m_scene.LandChannel.UpdateLandObject(LandData.LocalID, newData);
+                SendLandUpdateToAvatarsOverMe(snap_selection);
+            }
         }
 
         public void UpdateLandSold(UUID avatarID, UUID groupID, bool groupOwned, uint AuctionID, int claimprice, int area)
@@ -950,7 +952,7 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         public void SendForceObjectSelect(int local_id, int request_type, List<UUID> returnIDs, IClientAPI remote_client)
         {
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandOptions))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandOptions, true))
             {
                 List<uint> resultLocalIDs = new List<uint>();
                 try
@@ -1000,7 +1002,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         /// </param>
         public void SendLandObjectOwners(IClientAPI remote_client)
         {
-            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandOptions))
+            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandOptions, true))
             {
                 Dictionary<UUID, int> primCount = new Dictionary<UUID, int>();
                 List<UUID> groups = new List<UUID>();
diff --git a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
index 79dd4a0..4f5b9b7 100644
--- a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
+++ b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
@@ -42,8 +42,8 @@ using PermissionMask = OpenSim.Framework.PermissionMask;
 
 namespace OpenSim.Region.CoreModules.World.Permissions
 {
-    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "PermissionsModule")]
-    public class PermissionsModule : INonSharedRegionModule, IPermissionsModule
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "DefaultPermissionsModule")]
+    public class DefaultPermissionsModule : INonSharedRegionModule, IPermissionsModule
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
                 
@@ -348,7 +348,7 @@ namespace OpenSim.Region.CoreModules.World.Permissions
 
         public string Name
         {
-            get { return "PermissionsModule"; }
+            get { return "DefaultPermissionsModule"; }
         }
 
         public Type ReplaceableInterface
@@ -1047,7 +1047,7 @@ namespace OpenSim.Region.CoreModules.World.Permissions
             return GenericObjectPermission(editorID, objectID, false);
         }
 
-        private bool CanEditParcelProperties(UUID user, ILandObject parcel, GroupPowers p, Scene scene)
+        private bool CanEditParcelProperties(UUID user, ILandObject parcel, GroupPowers p, Scene scene, bool allowManager)
         {
             DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
             if (m_bypassPermissions) return m_bypassPermissionsValue;
diff --git a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
index 09481a7..f0e639d 100644
--- a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
+++ b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
@@ -662,7 +662,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             // Do the frame processing
             double steps = (double)m_currentFrame.TimeMS / tickDuration;
-
+            
             if (steps <= 0.0)
             {
                 m_group.RootPart.Velocity = Vector3.Zero;
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs b/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
index 535d87a..4d90726 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
@@ -70,7 +70,7 @@ namespace OpenSim.Region.Framework.Scenes
     public delegate bool IsGridGodHandler(UUID user, Scene requestFromScene);
     public delegate bool IsAdministratorHandler(UUID user);
     public delegate bool EditParcelHandler(UUID user, ILandObject parcel, Scene scene);
-    public delegate bool EditParcelPropertiesHandler(UUID user, ILandObject parcel, GroupPowers p, Scene scene);
+    public delegate bool EditParcelPropertiesHandler(UUID user, ILandObject parcel, GroupPowers p, Scene scene, bool allowManager);
     public delegate bool SellParcelHandler(UUID user, ILandObject parcel, Scene scene);
     public delegate bool AbandonParcelHandler(UUID user, ILandObject parcel, Scene scene);
     public delegate bool ReclaimParcelHandler(UUID user, ILandObject parcel, Scene scene);
@@ -763,7 +763,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         #region EDIT PARCEL
 
-        public bool CanEditParcelProperties(UUID user, ILandObject parcel, GroupPowers p)
+        public bool CanEditParcelProperties(UUID user, ILandObject parcel, GroupPowers p, bool allowManager)
         {
             EditParcelPropertiesHandler handler = OnEditParcelProperties;
             if (handler != null)
@@ -771,7 +771,7 @@ namespace OpenSim.Region.Framework.Scenes
                 Delegate[] list = handler.GetInvocationList();
                 foreach (EditParcelPropertiesHandler h in list)
                 {
-                    if (h(user, parcel, p, m_scene) == false)
+                    if (h(user, parcel, p, m_scene, allowManager) == false)
                         return false;
                 }
             }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 2b58795..b189599 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -2802,8 +2802,10 @@ namespace OpenSim.Region.Framework.Scenes
                 newObject.RootPart.ParentGroup.CreateScriptInstances(0, false, DefaultScriptEngine, GetStateSource(newObject));
                 newObject.ResumeScripts();
 
-                if (newObject.RootPart.KeyframeMotion != null)
-                    newObject.RootPart.KeyframeMotion.UpdateSceneObject(newObject);
+                // AddSceneObject already does this and doing it again messes
+                // up region crossings, so don't.
+                //if (newObject.RootPart.KeyframeMotion != null)
+                //    newObject.RootPart.KeyframeMotion.UpdateSceneObject(newObject);
             }
 
             // Do this as late as possible so that listeners have full access to the incoming object
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 0ea4e09..86f60bb 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -591,6 +591,7 @@ namespace OpenSim.Region.Framework.Scenes
                                 avinfo.ParentID = av.ParentID;
                                 avsToCross.Add(avinfo);
 
+                                av.PrevSitOffset = av.OffsetPosition;
                                 av.ParentID = 0;
                             }
 
@@ -1072,6 +1073,11 @@ namespace OpenSim.Region.Framework.Scenes
             for (int i = 0; i < parts.Length; i++)
             {
                 SceneObjectPart part = parts[i];
+                if (part.KeyframeMotion != null)
+                {
+                    part.KeyframeMotion.UpdateSceneObject(this);
+                }
+
                 if (Object.ReferenceEquals(part, m_rootPart))
                     continue;
 
@@ -1880,25 +1886,27 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 SceneObjectPart part = parts[i];
 
-                Scene.ForEachRootScenePresence(delegate(ScenePresence avatar)
+                if (Scene != null)
                 {
-                    if (avatar.ParentID == LocalId)
-                        avatar.StandUp();
-
-                    if (!silent)
+                    Scene.ForEachRootScenePresence(delegate(ScenePresence avatar)
                     {
-                        part.ClearUpdateSchedule();
-                        if (part == m_rootPart)
+                        if (avatar.ParentID == LocalId)
+                            avatar.StandUp();
+
+                        if (!silent)
                         {
-                            if (!IsAttachment
-                                || AttachedAvatar == avatar.ControllingClient.AgentId
-                                || !HasPrivateAttachmentPoint)
-                                avatar.ControllingClient.SendKillObject(m_regionHandle, new List<uint> { part.LocalId });
+                            part.ClearUpdateSchedule();
+                            if (part == m_rootPart)
+                            {
+                                if (!IsAttachment
+                                    || AttachedAvatar == avatar.ControllingClient.AgentId
+                                    || !HasPrivateAttachmentPoint)
+                                    avatar.ControllingClient.SendKillObject(m_regionHandle, new List<uint> { part.LocalId });
+                            }
                         }
-                    }
-                });
+                    });
+                }
             }
-
         }
 
         public void AddScriptLPS(int count)
@@ -3483,8 +3491,8 @@ namespace OpenSim.Region.Framework.Scenes
                     part.ClonePermissions(RootPart);
             });
 
-            uint lockMask = ~(uint)PermissionMask.Move;
-            uint lockBit = RootPart.OwnerMask & (uint)PermissionMask.Move;
+            uint lockMask = ~(uint)(PermissionMask.Move | PermissionMask.Modify);
+            uint lockBit = RootPart.OwnerMask & (uint)(PermissionMask.Move | PermissionMask.Modify);
             RootPart.OwnerMask = (RootPart.OwnerMask & lockBit) | ((newOwnerMask | foldedPerms) & lockMask);
             RootPart.ScheduleFullUpdate();
         }
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 0ab267a..7004d23 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -242,7 +242,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         private int m_movementAnimationUpdateCounter = 0;
 
-        private Vector3 m_prevSitOffset;
+        public Vector3 PrevSitOffset { get; set; }
 
         protected AvatarAppearance m_appearance;
 
@@ -957,7 +957,7 @@ namespace OpenSim.Region.Framework.Scenes
 //                    ParentPosition = part.GetWorldPosition();
                     ParentID = part.LocalId;
                     ParentPart = part;
-                    m_pos = m_prevSitOffset;
+                    m_pos = PrevSitOffset;
 //                    pos = ParentPosition;
                     pos = part.GetWorldPosition();
                 }
@@ -2261,6 +2261,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (ParentID != 0)
             {
+                PrevSitOffset = m_pos; // Save sit offset
                 SceneObjectPart part = ParentPart;
                 UnRegisterSeatControls(part.ParentGroup.UUID);
 
@@ -3487,7 +3488,7 @@ namespace OpenSim.Region.Framework.Scenes
             cAgent.Appearance = new AvatarAppearance(Appearance);
 
             cAgent.ParentPart = ParentUUID;
-            cAgent.SitOffset = m_pos;
+            cAgent.SitOffset = PrevSitOffset;
             
             lock (scriptedcontrols)
             {
@@ -3530,7 +3531,7 @@ namespace OpenSim.Region.Framework.Scenes
             CameraLeftAxis = cAgent.LeftAxis;
             CameraUpAxis = cAgent.UpAxis;
             ParentUUID = cAgent.ParentPart;
-            m_prevSitOffset = cAgent.SitOffset;
+            PrevSitOffset = cAgent.SitOffset;
 
             // When we get to the point of re-computing neighbors everytime this
             // changes, then start using the agent's drawdistance rather than the 
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
index 52ad538..9557cd0 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectDeRezTests.cs
@@ -67,7 +67,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             IConfigSource configSource = new IniConfigSource();
             IConfig config = configSource.AddConfig("Startup");
             config.Set("serverside_object_permissions", true);
-            SceneHelpers.SetupSceneModules(scene, configSource, new object[] { new PermissionsModule() });
+            SceneHelpers.SetupSceneModules(scene, configSource, new object[] { new DefaultPermissionsModule() });
             IClientAPI client = SceneHelpers.AddScenePresence(scene, userId).ControllingClient;
             
             // Turn off the timer on the async sog deleter - we'll crank it by hand for this test.
@@ -112,7 +112,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             IConfigSource configSource = new IniConfigSource();
             IConfig config = configSource.AddConfig("Startup");
             config.Set("serverside_object_permissions", true);
-            SceneHelpers.SetupSceneModules(scene, configSource, new object[] { new PermissionsModule() });            
+            SceneHelpers.SetupSceneModules(scene, configSource, new object[] { new DefaultPermissionsModule() });            
             IClientAPI client = SceneHelpers.AddScenePresence(scene, userId).ControllingClient;
             
             // Turn off the timer on the async sog deleter - we'll crank it by hand for this test.
@@ -195,4 +195,4 @@ namespace OpenSim.Region.Framework.Scenes.Tests
 //            Assert.That(retrievedPart, Is.Null);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
index c7eaff9..e7a1fe0 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneObjectUserGroupTests.cs
@@ -71,7 +71,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
                        
             SceneHelpers.SetupSceneModules(
                 scene, configSource, new object[] 
-                   { new PermissionsModule(), 
+                   { new DefaultPermissionsModule(), 
                      new GroupsModule(), 
                      new MockGroupsServicesConnector() });
             
@@ -82,4 +82,4 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             groupsModule.CreateGroup(client, "group1", "To boldly go", true, UUID.Zero, 5, true, true, true);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
index de4458d..8d94d29 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceTeleportTests.cs
@@ -216,7 +216,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             // We need to set up the permisions module on scene B so that our later use of agent limit to deny
             // QueryAccess won't succeed anyway because administrators are always allowed in and the default
             // IsAdministrator if no permissions module is present is true.
-            SceneHelpers.SetupSceneModules(sceneB, config, new object[] { new PermissionsModule(), etmB });
+            SceneHelpers.SetupSceneModules(sceneB, config, new object[] { new DefaultPermissionsModule(), etmB });
 
             // Shared scene modules
             SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
@@ -381,7 +381,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             // We need to set up the permisions module on scene B so that our later use of agent limit to deny
             // QueryAccess won't succeed anyway because administrators are always allowed in and the default
             // IsAdministrator if no permissions module is present is true.
-            SceneHelpers.SetupSceneModules(sceneB, config, new object[] { new PermissionsModule(), etmB });
+            SceneHelpers.SetupSceneModules(sceneB, config, new object[] { new DefaultPermissionsModule(), etmB });
 
             // Shared scene modules
             SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
@@ -507,4 +507,4 @@ namespace OpenSim.Region.Framework.Scenes.Tests
 //            TestHelpers.DisableLogging();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs b/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs
index e756c70..9e6cc1a 100644
--- a/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs
@@ -635,15 +635,15 @@ namespace OpenSim.Region.OptionalModules.Avatar.Voice.VivoxVoice
                 // TODO: EstateSettings don't seem to get propagated...
                 if (!scene.RegionInfo.EstateSettings.AllowVoice)
                 {
-                    m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": voice not enabled in estate settings",
-                                      scene.RegionInfo.RegionName);
+                    //m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": voice not enabled in estate settings",
+                    //                  scene.RegionInfo.RegionName);
                     channel_uri = String.Empty;
                 }
 
                 if ((land.Flags & (uint)ParcelFlags.AllowVoiceChat) == 0)
                 {
-                    m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": voice not enabled for parcel",
-                                      scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName);
+                    //m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": voice not enabled for parcel",
+                    //                  scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName);
                     channel_uri = String.Empty;
                 }
                 else
diff --git a/OpenSim/Region/OptionalModules/World/MoneyModule/SampleMoneyModule.cs b/OpenSim/Region/OptionalModules/World/MoneyModule/SampleMoneyModule.cs
index 0c9fdb9..5d10e93 100644
--- a/OpenSim/Region/OptionalModules/World/MoneyModule/SampleMoneyModule.cs
+++ b/OpenSim/Region/OptionalModules/World/MoneyModule/SampleMoneyModule.cs
@@ -203,8 +203,9 @@ namespace OpenSim.Region.OptionalModules.World.MoneyModule
         {
         }
 
-        public bool ObjectGiveMoney(UUID objectID, UUID fromID, UUID toID, int amount, UUID txn)
+        public bool ObjectGiveMoney(UUID objectID, UUID fromID, UUID toID, int amount, UUID txn, out string result)
         {
+            result = String.Empty;
             string description = String.Format("Object {0} pays {1}", resolveObjectName(objectID), resolveAgentName(toID));
 
             bool give_result = doMoneyTransfer(fromID, toID, amount, 2, description);
diff --git a/OpenSim/Region/RegionCombinerModule/RegionCombinerPermissionModule.cs b/OpenSim/Region/RegionCombinerModule/RegionCombinerPermissionModule.cs
index 7c662c9..40ed3fd 100644
--- a/OpenSim/Region/RegionCombinerModule/RegionCombinerPermissionModule.cs
+++ b/OpenSim/Region/RegionCombinerModule/RegionCombinerPermissionModule.cs
@@ -105,9 +105,9 @@ namespace OpenSim.Region.RegionCombinerModule
             return m_rootScene.Permissions.CanEditObject(objectid, editorid);
         }
 
-        public bool CanEditParcelProperties(UUID user, ILandObject parcel, GroupPowers g, Scene scene)
+        public bool CanEditParcelProperties(UUID user, ILandObject parcel, GroupPowers g, Scene scene, bool allowManager)
         {
-            return m_rootScene.Permissions.CanEditParcelProperties(user, parcel, g);
+            return m_rootScene.Permissions.CanEditParcelProperties(user, parcel, g, allowManager);
         }
 
         public bool CanInstantMessage(UUID user, UUID target, Scene startscene)
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index 5ea14c7..3f0af6d 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -3109,8 +3109,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                     return;
                 }
 
+                string reason;
                 money.ObjectGiveMoney(
-                    m_host.ParentGroup.RootPart.UUID, m_host.ParentGroup.RootPart.OwnerID, toID, amount,UUID.Zero);
+                    m_host.ParentGroup.RootPart.UUID, m_host.ParentGroup.RootPart.OwnerID, toID, amount,UUID.Zero, out reason);
             });
 
             return 0;
@@ -7105,7 +7106,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             UUID key;
             ILandObject land = World.LandChannel.GetLandObject(m_host.AbsolutePosition);
 
-            if (World.Permissions.CanEditParcelProperties(m_host.OwnerID, land, GroupPowers.LandManageBanned))
+            if (World.Permissions.CanEditParcelProperties(m_host.OwnerID, land, GroupPowers.LandManageBanned, false))
             {
                 int expires = 0;
                 if (hours != 0)
@@ -10430,7 +10431,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             // according to the docs, this command only works if script owner and land owner are the same
             // lets add estate owners and gods, too, and use the generic permission check.
             ILandObject landObject = World.LandChannel.GetLandObject(m_host.AbsolutePosition);
-            if (!World.Permissions.CanEditParcelProperties(m_host.OwnerID, landObject, GroupPowers.ChangeMedia)) return;
+            if (!World.Permissions.CanEditParcelProperties(m_host.OwnerID, landObject, GroupPowers.ChangeMedia, false)) return;
 
             bool update = false; // send a ParcelMediaUpdate (and possibly change the land's media URL)?
             byte loop = 0;
@@ -10873,7 +10874,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             m_host.AddScriptLPS(1);
             UUID key;
             ILandObject land = World.LandChannel.GetLandObject(m_host.AbsolutePosition);
-            if (World.Permissions.CanEditParcelProperties(m_host.OwnerID, land, GroupPowers.LandManageBanned))
+            if (World.Permissions.CanEditParcelProperties(m_host.OwnerID, land, GroupPowers.LandManageBanned, false))
             {
                 int expires = 0;
                 if (hours != 0)
@@ -10914,7 +10915,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             m_host.AddScriptLPS(1);
             UUID key;
             ILandObject land = World.LandChannel.GetLandObject(m_host.AbsolutePosition);
-            if (World.Permissions.CanEditParcelProperties(m_host.OwnerID, land, GroupPowers.LandManageAllowed))
+            if (World.Permissions.CanEditParcelProperties(m_host.OwnerID, land, GroupPowers.LandManageAllowed, false))
             {
                 if (UUID.TryParse(avatar, out key))
                 {
@@ -10941,7 +10942,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             m_host.AddScriptLPS(1);
             UUID key;
             ILandObject land = World.LandChannel.GetLandObject(m_host.AbsolutePosition);
-            if (World.Permissions.CanEditParcelProperties(m_host.OwnerID, land, GroupPowers.LandManageBanned))
+            if (World.Permissions.CanEditParcelProperties(m_host.OwnerID, land, GroupPowers.LandManageBanned, false))
             {
                 if (UUID.TryParse(avatar, out key))
                 {
@@ -12784,8 +12785,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                         return;
                     }
 
+                    string reason;
                     bool result = money.ObjectGiveMoney(
-                        m_host.ParentGroup.RootPart.UUID, m_host.ParentGroup.RootPart.OwnerID, toID, amount, txn);
+                        m_host.ParentGroup.RootPart.UUID, m_host.ParentGroup.RootPart.OwnerID, toID, amount, txn, out reason);
 
                     if (result)
                     {
@@ -12793,7 +12795,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                         return;
                     }
 
-                    replydata = "LINDENDOLLAR_INSUFFICIENTFUNDS";
+                    replydata = reason;
                 }
                 finally
                 {
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
index f4e4f44..9c148d1 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
@@ -1434,7 +1434,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                 return;
             }
 
-            if (!World.Permissions.CanEditParcelProperties(m_host.OwnerID, startLandObject, GroupPowers.LandOptions))
+            if (!World.Permissions.CanEditParcelProperties(m_host.OwnerID, startLandObject, GroupPowers.LandOptions, false))
             {
                 OSSLShoutError("You do not have permission to modify the parcel");
                 return;
diff --git a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
index 26850c4..a2ac9c5 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Instance/ScriptInstance.cs
@@ -231,6 +231,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Instance
                 ItemID = ScriptTask.ItemID;
                 AssetID = ScriptTask.AssetID;
             }
+            LocalID = part.LocalId;
 
             PrimName = part.ParentGroup.Name;
             StartParam = startParam;
diff --git a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
index 17243ab..04a4e53 100644
--- a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
+++ b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
@@ -1316,13 +1316,21 @@ namespace OpenSim.Region.ScriptEngine.XEngine
 
             ScriptInstance instance = null;
             // Create the object record
+            UUID appDomain = assetID;
+           
+
+          
             lockScriptsForRead(true);
             if ((!m_Scripts.ContainsKey(itemID)) ||
                 (m_Scripts[itemID].AssetID != assetID))
             {
                 lockScriptsForRead(false);
-
-                UUID appDomain = assetID;
+  instance = new ScriptInstance(this, part,
+                                          item,
+                                          startParam, postOnRez,
+                                          m_MaxScriptQueue);
+                
+                
 
                 if (part.ParentGroup.IsAttachment)
                     appDomain = part.ParentGroup.RootPart.UUID;
@@ -1345,9 +1353,39 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                             sandbox = AppDomain.CreateDomain(
                                             m_Scene.RegionInfo.RegionID.ToString(),
                                             evidence, appSetup);
-                            m_AppDomains[appDomain].AssemblyResolve +=
-                                new ResolveEventHandler(
-                                    AssemblyResolver.OnAssemblyResolve);
+                            if (m_AppDomains.ContainsKey(appDomain))
+                            {
+                                m_AppDomains[appDomain].AssemblyResolve +=
+                                    new ResolveEventHandler(
+                                        AssemblyResolver.OnAssemblyResolve);
+                                if (m_DomainScripts.ContainsKey(appDomain))
+                                {
+                                    m_DomainScripts[appDomain].Add(itemID);
+                                }
+                                else
+                                {
+                                    m_DomainScripts.Add(appDomain, new List<UUID>());
+                                    m_DomainScripts[appDomain].Add(itemID);
+                                }
+                            }
+                            else
+                            {
+                                m_AppDomains.Add(appDomain, sandbox);
+                                m_AppDomains[appDomain].AssemblyResolve +=
+                                    new ResolveEventHandler(
+                                        AssemblyResolver.OnAssemblyResolve);
+                                if (m_DomainScripts.ContainsKey(appDomain))
+                                {
+                                    m_DomainScripts[appDomain].Add(itemID);
+                                }
+                                else
+                                {
+                                    m_DomainScripts.Add(appDomain, new List<UUID>());
+                                    m_DomainScripts[appDomain].Add(itemID);
+                                }
+
+                            }
+
                         }
                         else
                         {
@@ -1373,12 +1411,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                         return false;
                     }
                 }
-                m_DomainScripts[appDomain].Add(itemID);
-
-                instance = new ScriptInstance(this, part,
-                                              item,
-                                              startParam, postOnRez,
-                                              m_MaxScriptQueue);
+                
 
                 instance.Load(m_AppDomains[appDomain], assembly, stateSource);
 //                m_log.DebugFormat(
@@ -1502,6 +1535,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             if (handlerObjectRemoved != null)
             {
                 SceneObjectPart part = m_Scene.GetSceneObjectPart(localID);                    
+                if (part != null)
                 handlerObjectRemoved(part.UUID);
             }
 
diff --git a/OpenSim/Server/Base/HttpServerBase.cs b/OpenSim/Server/Base/HttpServerBase.cs
index 954783c..eed2645 100644
--- a/OpenSim/Server/Base/HttpServerBase.cs
+++ b/OpenSim/Server/Base/HttpServerBase.cs
@@ -40,7 +40,7 @@ namespace OpenSim.Server.Base
 {
     public class HttpServerBase : ServicesServerBase
     {
-//        private static readonly ILog m_Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private uint m_consolePort;
 
@@ -69,6 +69,7 @@ namespace OpenSim.Server.Base
 
             bool ssl_main = networkConfig.GetBoolean("https_main",false);
             bool ssl_listener = networkConfig.GetBoolean("https_listener",false);
+            bool ssl_external = networkConfig.GetBoolean("https_external",false);
 
             m_consolePort = (uint)networkConfig.GetInt("ConsolePort", 0);
 
@@ -113,20 +114,29 @@ namespace OpenSim.Server.Base
 
                 uint https_port = (uint)networkConfig.GetInt("https_port", 0);
 
-                string cert_path = networkConfig.GetString("cert_path",String.Empty);
-                if ( cert_path == String.Empty )
+                m_log.WarnFormat("[SSL]: External flag is {0}", ssl_external);
+                if (!ssl_external)
                 {
-                    System.Console.WriteLine("Path to X509 certificate is missing, server can't start.");
-                    Thread.CurrentThread.Abort();
+                    string cert_path = networkConfig.GetString("cert_path",String.Empty);
+                    if ( cert_path == String.Empty )
+                    {
+                        System.Console.WriteLine("Path to X509 certificate is missing, server can't start.");
+                        Thread.CurrentThread.Abort();
+                    }
+                    string cert_pass = networkConfig.GetString("cert_pass",String.Empty);
+                    if ( cert_pass == String.Empty )
+                    {
+                        System.Console.WriteLine("Password for X509 certificate is missing, server can't start.");
+                        Thread.CurrentThread.Abort();
+                    }
+
+                    MainServer.AddHttpServer(new BaseHttpServer(https_port, ssl_listener, cert_path, cert_pass));
                 }
-                string cert_pass = networkConfig.GetString("cert_pass",String.Empty);
-                if ( cert_pass == String.Empty )
+                else
                 {
-                    System.Console.WriteLine("Password for X509 certificate is missing, server can't start.");
-                    Thread.CurrentThread.Abort();
+                    m_log.WarnFormat("[SSL]: SSL port is active but no SSL is used because external SSL was requested.");
+                    MainServer.AddHttpServer(new BaseHttpServer(https_port));
                 }
-
-                MainServer.AddHttpServer(new BaseHttpServer(https_port, ssl_listener, cert_path, cert_pass));
             }
         }
 
diff --git a/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs b/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
index 4b502b7..8b702e0 100644
--- a/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
+++ b/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
@@ -137,7 +137,13 @@ namespace OpenSim.Services.Connectors
 
             string prefix = id.Substring(0, 2).ToLower();
 
-            string host = m_UriMap[prefix];
+            string host;
+            
+            // HG URLs will not be valid UUIDS
+            if (m_UriMap.ContainsKey(prefix))
+                host = m_UriMap[prefix];
+            else
+                host = m_UriMap["00"];
 
             serverUri.Host = host;
 
diff --git a/OpenSim/Services/Connectors/MapImage/MapImageServicesConnector.cs b/OpenSim/Services/Connectors/MapImage/MapImageServicesConnector.cs
index 30bfb70..267dd71 100644
--- a/OpenSim/Services/Connectors/MapImage/MapImageServicesConnector.cs
+++ b/OpenSim/Services/Connectors/MapImage/MapImageServicesConnector.cs
@@ -86,6 +86,66 @@ namespace OpenSim.Services.Connectors
             m_ServerURI = serviceURI.TrimEnd('/');
         }
 
+        public bool RemoveMapTile(int x, int y, out string reason)
+        {
+            reason = string.Empty;
+            int tickstart = Util.EnvironmentTickCount();
+            Dictionary<string, object> sendData = new Dictionary<string, object>();
+            sendData["X"] = x.ToString();
+            sendData["Y"] = y.ToString();
+
+            string reqString = ServerUtils.BuildQueryString(sendData);
+            string uri = m_ServerURI + "/removemap";
+
+            try
+            {
+                string reply = SynchronousRestFormsRequester.MakeRequest("POST",
+                        uri,
+                        reqString);
+                if (reply != string.Empty)
+                {
+                    Dictionary<string, object> replyData = ServerUtils.ParseXmlResponse(reply);
+
+                    if (replyData.ContainsKey("Result") && (replyData["Result"].ToString().ToLower() == "success"))
+                    {
+                        return true;
+                    }
+                    else if (replyData.ContainsKey("Result") && (replyData["Result"].ToString().ToLower() == "failure"))
+                    {
+                        m_log.DebugFormat("[MAP IMAGE CONNECTOR]: Delete failed: {0}", replyData["Message"].ToString());
+                        reason = replyData["Message"].ToString();
+                        return false;
+                    }
+                    else if (!replyData.ContainsKey("Result"))
+                    {
+                        m_log.DebugFormat("[MAP IMAGE CONNECTOR]: reply data does not contain result field");
+                    }
+                    else
+                    {
+                        m_log.DebugFormat("[MAP IMAGE CONNECTOR]: unexpected result {0}", replyData["Result"].ToString());
+                        reason = "Unexpected result " + replyData["Result"].ToString();
+                    }
+
+                }
+                else
+                {
+                    m_log.DebugFormat("[MAP IMAGE CONNECTOR]: Map post received null reply");
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[MAP IMAGE CONNECTOR]: Exception when contacting map server at {0}: {1}", uri, e.Message);
+            }
+            finally
+            {
+                // This just dumps a warning for any operation that takes more than 100 ms
+                int tickdiff = Util.EnvironmentTickCountSubtract(tickstart);
+                m_log.DebugFormat("[MAP IMAGE CONNECTOR]: map tile deleted in {0}ms", tickdiff);
+            }
+
+            return false;
+        }
+
         public bool AddMapTile(int x, int y, byte[] jpgData, out string reason)
         {
             reason = string.Empty;
diff --git a/OpenSim/Services/GridService/GridService.cs b/OpenSim/Services/GridService/GridService.cs
index daebf8b..7f71835 100644
--- a/OpenSim/Services/GridService/GridService.cs
+++ b/OpenSim/Services/GridService/GridService.cs
@@ -283,7 +283,7 @@ namespace OpenSim.Services.GridService
 
             int flags = Convert.ToInt32(region.Data["flags"]);
 
-            if (!m_DeleteOnUnregister || (flags & (int)OpenSim.Framework.RegionFlags.Persistent) != 0)
+            if ((!m_DeleteOnUnregister) || ((flags & (int)OpenSim.Framework.RegionFlags.Persistent) != 0))
             {
                 flags &= ~(int)OpenSim.Framework.RegionFlags.RegionOnline;
                 region.Data["flags"] = flags.ToString();
@@ -298,7 +298,6 @@ namespace OpenSim.Services.GridService
                 }
 
                 return true;
-
             }
 
             return m_Database.Delete(regionID);
diff --git a/OpenSim/Services/Interfaces/IMapImageService.cs b/OpenSim/Services/Interfaces/IMapImageService.cs
index a7b2cf1..78daa5f 100644
--- a/OpenSim/Services/Interfaces/IMapImageService.cs
+++ b/OpenSim/Services/Interfaces/IMapImageService.cs
@@ -35,6 +35,7 @@ namespace OpenSim.Services.Interfaces
     {
         //List<MapBlockData> GetMapBlocks(UUID scopeID, int minX, int minY, int maxX, int maxY);
         bool AddMapTile(int x, int y, byte[] imageData, out string reason);
+        bool RemoveMapTile(int x, int y, out string reason);
         byte[] GetMapTile(string fileName, out string format);
     }
 }
diff --git a/OpenSim/Services/MapImageService/MapImageService.cs b/OpenSim/Services/MapImageService/MapImageService.cs
index a85ee70..e2f256f 100644
--- a/OpenSim/Services/MapImageService/MapImageService.cs
+++ b/OpenSim/Services/MapImageService/MapImageService.cs
@@ -112,9 +112,38 @@ namespace OpenSim.Services.MapImageService
                     reason = e.Message;
                     return false;
                 }
+            }
+
+            return UpdateMultiResolutionFiles(x, y, out reason);
+        }
+
+        public bool RemoveMapTile(int x, int y, out string reason)
+        {
+            reason = String.Empty;
+            string fileName = GetFileName(1, x, y);
+
+            lock (m_Sync)
+            {
+                try
+                {
+                    File.Delete(fileName);
+                }
+                catch (Exception e)
+                {
+                    m_log.WarnFormat("[MAP IMAGE SERVICE]: Unable to save delete file {0}: {1}", fileName, e);
+                    reason = e.Message;
+                    return false;
+                }
+            }
 
-                // Also save in png format?
+            return UpdateMultiResolutionFiles(x, y, out reason);
+        }
 
+        private bool UpdateMultiResolutionFiles(int x, int y, out string reason)
+        {
+            reason = String.Empty;
+            lock (m_Sync)
+            {
                 // Stitch seven more aggregate tiles together
                 for (uint zoomLevel = 2; zoomLevel <= ZOOM_LEVELS; zoomLevel++)
                 {
@@ -126,7 +155,7 @@ namespace OpenSim.Services.MapImageService
 
                     if (!CreateTile(zoomLevel, x1, y1))
                     {
-                        m_log.WarnFormat("[MAP IMAGE SERVICE]: Unable to create tile for {0} at zoom level {1}", fileName, zoomLevel);
+                        m_log.WarnFormat("[MAP IMAGE SERVICE]: Unable to create tile for {0},{1} at zoom level {1}", x, y, zoomLevel);
                         reason = string.Format("Map tile at zoom level {0} failed", zoomLevel);
                         return false;
                     }