viewer crash bug fix: fis the udp packets split of SendEstateList() large lists; Enforce size limits on the estate lists since currently required for viewers compatibily; improve handling of changes with large selected items. This is still bad, users may need to close and reopen the region/estate information to get correct Allowed and Banned lists after a change. This happens because of viewer resent/outOfOrder packets that completly break this lists updates protocol

1 files changed, 322 insertions, 205 deletions

diff --git a/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs b/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
index 87fb0db..8eb2b1e 100644
--- a/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Estate/EstateManagementModule.cs
@@ -33,15 +33,19 @@ using System.Linq;
 using System.Reflection;
 using System.Security;
 using System.Timers;
+using System.Threading;
 using log4net;
 using Mono.Addins;
 using Nini.Config;
 using OpenMetaverse;
 using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
 using RegionFlags = OpenMetaverse.RegionFlags;
+using Timer = System.Timers.Timer;
+
 
 namespace OpenSim.Region.CoreModules.World.Estate
 {
@@ -441,7 +445,7 @@ namespace OpenSim.Region.CoreModules.World.Estate
                     Scene.RegionInfo.EstateSettings.EstateID);
 
             remote_client.SendEstateList(invoice,
-                    (int)Constants.EstateAccessCodex.AccessOptions,
+                    (int)Constants.EstateAccessCodex.AllowedAccess,
                     Scene.RegionInfo.EstateSettings.EstateAccess,
                     Scene.RegionInfo.EstateSettings.EstateID);
 
@@ -651,227 +655,354 @@ namespace OpenSim.Region.CoreModules.World.Estate
             TriggerRegionInfoChange();
         }
 
-        private void handleEstateAccessDeltaRequest(IClientAPI remote_client, UUID invoice, int estateAccessType, UUID user)
+        private object deltareqLock = new object();
+        private bool runnigDeltaExec = false;
+
+        private class EstateAccessDeltaRequest
+        {
+            public IClientAPI remote_client;
+            public UUID invoice;
+            public int estateAccessType;
+            public UUID user;
+        }
+
+        private OpenSim.Framework.BlockingQueue<EstateAccessDeltaRequest> deltaRequests = new OpenSim.Framework.BlockingQueue<EstateAccessDeltaRequest>();
+
+        private void handleEstateAccessDeltaRequest(IClientAPI _remote_client, UUID _invoice, int _estateAccessType, UUID _user)
         {
             // EstateAccessDelta handles Estate Managers, Sim Access, Sim Banlist, allowed Groups..  etc.
 
-            if (user == Scene.RegionInfo.EstateSettings.EstateOwner)
+            if (_user == Scene.RegionInfo.EstateSettings.EstateOwner)
                 return; // never process EO
 
-            if ((estateAccessType & 4) != 0) // User add
+            EstateAccessDeltaRequest newreq = new EstateAccessDeltaRequest();
+            newreq.remote_client = _remote_client;
+            newreq.invoice = _invoice;
+            newreq.estateAccessType = _estateAccessType;
+            newreq.user = _user;
+
+            deltaRequests.Enqueue(newreq);
+
+            lock(deltareqLock)
+            {
+                if(!runnigDeltaExec)
+                {
+                    runnigDeltaExec = true;
+                    WorkManager.RunInThreadPool(execDeltaRequests,null,"execDeltaRequests");
+                }
+            }
+        }
+ 
+        private void execDeltaRequests(object o)
+        {
+            IClientAPI remote_client;
+            UUID invoice;
+            int estateAccessType;
+            UUID user;
+            Dictionary<int,EstateSettings> changed = new Dictionary<int,EstateSettings>();
+            Dictionary<IClientAPI,UUID> sendAllowedOrBanList = new Dictionary<IClientAPI,UUID>();
+            Dictionary<IClientAPI,UUID> sendManagers  = new Dictionary<IClientAPI,UUID>();
+            Dictionary<IClientAPI,UUID> sendGroups  = new Dictionary<IClientAPI,UUID>();
+
+            List<EstateSettings> otherEstates = new List<EstateSettings>();
+
+            bool sentAllowedFull = false;
+            bool sentBansFull = false;
+            bool sentGroupsFull = false;
+            bool sentManagersFull = false;
+
+            while(Scene.IsRunning)
             {
-                if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true))
+                EstateAccessDeltaRequest req = deltaRequests.Dequeue(500);
+
+                if(!Scene.IsRunning)
+                    break;
+
+                if(req == null) 
                 {
-                    if ((estateAccessType & 1) != 0) // All estates
+                    if(changed.Count > 0)
                     {
-                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
-                        EstateSettings estateSettings;
+                        foreach(EstateSettings est in changed.Values)
+                            Scene.EstateDataService.StoreEstateSettings(est);
+                            
+                        TriggerEstateInfoChange();
+                    }
+                        
+                    EstateSettings es = Scene.RegionInfo.EstateSettings;
+                    foreach(KeyValuePair<IClientAPI,UUID> kvp in sendAllowedOrBanList)
+                    {
+                        IClientAPI cli = kvp.Key;
+                        UUID invoive = kvp.Value;
+                        cli.SendEstateList(invoive, (int)Constants.EstateAccessCodex.AllowedAccess, es.EstateAccess, es.EstateID);
+                        cli.SendBannedUserList(invoive, es.EstateBans, es.EstateID);                       
+                    }
+                    sendAllowedOrBanList.Clear();
 
-                        foreach (int estateID in estateIDs)
-                        {
-                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
-                            {
-                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
-                                estateSettings.AddEstateUser(user);
-                                Scene.EstateDataService.StoreEstateSettings(estateSettings);
-                            }
-                        }
+                    foreach(KeyValuePair<IClientAPI,UUID> kvp in sendManagers)
+                    {
+                        IClientAPI cli = kvp.Key;
+                        cli.SendEstateList(kvp.Value, (int)Constants.EstateAccessCodex.EstateManagers, es.EstateManagers, es.EstateID);
+                    }
+                    foreach(KeyValuePair<IClientAPI,UUID> kvp in sendGroups)
+                    {
+                        IClientAPI cli = kvp.Key;
+                        cli.SendEstateList(kvp.Value, (int)Constants.EstateAccessCodex.AllowedGroups, es.EstateGroups, es.EstateID);
                     }
+                    otherEstates.Clear();
+                    sendAllowedOrBanList.Clear();
+                    sendManagers.Clear();
+                    sendGroups.Clear();
+                    changed.Clear();
+                    lock(deltareqLock)
+                    {
+                        if(deltaRequests.Count() != 0)
+                            continue;
+                        runnigDeltaExec = false;
+                        return;
+                    }
+                }
 
-                    Scene.RegionInfo.EstateSettings.AddEstateUser(user);
-                    Scene.EstateDataService.StoreEstateSettings(Scene.RegionInfo.EstateSettings);
+                remote_client = req.remote_client;
+                if(!remote_client.IsActive)
+                    continue;
 
-                    TriggerEstateInfoChange();
-                    remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.AccessOptions, Scene.RegionInfo.EstateSettings.EstateAccess, Scene.RegionInfo.EstateSettings.EstateID);
-                }
-                else
+                invoice = req.invoice;
+                user = req.user;
+
+                estateAccessType = req.estateAccessType;
+
+                bool needReply = ((estateAccessType & 1024) == 0);
+                bool doOtherEstates = ((estateAccessType & 3) != 0);
+
+                EstateSettings thisSettings = Scene.RegionInfo.EstateSettings;
+                int thisEstateID =(int)thisSettings.EstateID; 
+
+                UUID agentID = remote_client.AgentId;
+
+                bool isadmin = Scene.Permissions.IsAdministrator(agentID);
+                // just i case recheck rights
+                if (!isadmin && !Scene.Permissions.IsEstateManager(agentID))
                 {
-                    remote_client.SendAlertMessage("Method EstateAccessDelta Failed, you don't have permissions");
+                    remote_client.SendAlertMessage("Method EstateAccess Failed, you don't have permissions");
+                    continue;
                 }
 
-            }
-
-            if ((estateAccessType & 8) != 0) // User remove
-            {
-                if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true))
+                otherEstates.Clear();
+                if(doOtherEstates)
                 {
-                    if ((estateAccessType & 1) != 0) // All estates
+                    UUID thisOwner = Scene.RegionInfo.EstateSettings.EstateOwner;
+                    List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(thisOwner);
+                    foreach (int estateID in estateIDs)
                     {
-                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
+                        if (estateID == thisEstateID)
+                            continue;
+
                         EstateSettings estateSettings;
+                        if(changed.ContainsKey(estateID))
+                            estateSettings = changed[estateID];
+                        else
+                            estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
 
-                        foreach (int estateID in estateIDs)
+                        if(!isadmin && !estateSettings.IsEstateManagerOrOwner(agentID))
+                            continue;
+                        otherEstates.Add(estateSettings);
+                    }
+                    estateIDs.Clear();
+                }
+                
+                // the commands
+                // first the ones allowed for estate managers on this region
+                if ((estateAccessType & 4) != 0) // User add
+                {
+                    if(thisSettings.EstateUsersCount() >= (int)Constants.EstateAccessLimits.AllowedAccess)
+                    {
+                        if(!sentAllowedFull)
+                        {
+                            sentAllowedFull = true;
+                            remote_client.SendAlertMessage("Estate Allowed users list is full");
+                         }
+                    }
+                    else
+                    {
+                        if (doOtherEstates)
                         {
-                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                            foreach (EstateSettings estateSettings in otherEstates)
                             {
-                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
-                                estateSettings.RemoveEstateUser(user);
-                                Scene.EstateDataService.StoreEstateSettings(estateSettings);
+                                if(!isadmin && !estateSettings.IsEstateManagerOrOwner(agentID))
+                                    continue;
+                                if(estateSettings.EstateUsersCount() >= (int)Constants.EstateAccessLimits.AllowedAccess)
+                                    continue;
+                                estateSettings.AddEstateUser(user);
+                                estateSettings.RemoveBan(user);
+                                changed[(int)estateSettings.EstateID] = estateSettings;
                             }
                         }
-                    }
 
-                    Scene.RegionInfo.EstateSettings.RemoveEstateUser(user);
-                    Scene.EstateDataService.StoreEstateSettings(Scene.RegionInfo.EstateSettings);
+                        thisSettings.AddEstateUser(user);
+                        thisSettings.RemoveBan(user);
+                        changed[thisEstateID] = thisSettings;;
 
-                    TriggerEstateInfoChange();
-                    remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.AccessOptions, Scene.RegionInfo.EstateSettings.EstateAccess, Scene.RegionInfo.EstateSettings.EstateID);
+                        if(needReply)
+                            sendAllowedOrBanList[remote_client] = invoice;
+                    }
                 }
-                else
+
+                if ((estateAccessType & 8) != 0) // User remove
                 {
-                    remote_client.SendAlertMessage("Method EstateAccessDelta Failed, you don't have permissions");
+                    if (doOtherEstates) // All estates
+                    {
+                        foreach (EstateSettings estateSettings in otherEstates)
+                        {
+                            if(!isadmin && !estateSettings.IsEstateManagerOrOwner(agentID))
+                                continue;
+                            estateSettings.RemoveEstateUser(user);
+                            changed[(int)estateSettings.EstateID] = estateSettings;
+                        }
+                    }
+
+                    thisSettings.RemoveEstateUser(user);
+                    changed[thisEstateID] = thisSettings;;
+
+                    if(needReply)
+                        sendAllowedOrBanList[remote_client] = invoice;
                 }
-            }
 
-            if ((estateAccessType & 16) != 0) // Group add
-            {
-                if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true))
+                if ((estateAccessType & 16) != 0) // Group add
                 {
-                    if ((estateAccessType & 1) != 0) // All estates
+                    if(thisSettings.EstateGroupsCount() >= (int)Constants.EstateAccessLimits.AllowedGroups)
                     {
-                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
-                        EstateSettings estateSettings;
-
-                        foreach (int estateID in estateIDs)
+                        if(!sentGroupsFull)
                         {
-                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                            sentGroupsFull = true;
+                            remote_client.SendAlertMessage("Estate Allowed groups list is full");
+                         }
+                    }
+                    else
+                    {
+                        if (doOtherEstates) // All estates
+                        {
+                            foreach (EstateSettings estateSettings in otherEstates)
                             {
-                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                if(!isadmin && !estateSettings.IsEstateManagerOrOwner(agentID))
+                                    continue;
+                                if(estateSettings.EstateGroupsCount() >= (int)Constants.EstateAccessLimits.AllowedGroups)
+                                    continue;
                                 estateSettings.AddEstateGroup(user);
-                                Scene.EstateDataService.StoreEstateSettings(estateSettings);
+                                changed[(int)estateSettings.EstateID] = estateSettings;
                             }
                         }
-                    }
 
-                    Scene.RegionInfo.EstateSettings.AddEstateGroup(user);
-                    Scene.EstateDataService.StoreEstateSettings(Scene.RegionInfo.EstateSettings);
+                        thisSettings.AddEstateGroup(user);
+                        changed[thisEstateID] = thisSettings;
 
-                    TriggerEstateInfoChange();
-                    remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.AllowedGroups, Scene.RegionInfo.EstateSettings.EstateGroups, Scene.RegionInfo.EstateSettings.EstateID);
-                }
-                else
-                {
-                    remote_client.SendAlertMessage("Method EstateAccessDelta Failed, you don't have permissions");
+                        sendGroups[remote_client] = invoice;
+                    }
                 }
-            }
 
-            if ((estateAccessType & 32) != 0) // Group remove
-            {
-                if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true))
+                if ((estateAccessType & 32) != 0) // Group remove
                 {
-                    if ((estateAccessType & 1) != 0) // All estates
+                    if (doOtherEstates) // All estates
                     {
-                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
-                        EstateSettings estateSettings;
-
-                        foreach (int estateID in estateIDs)
+                        foreach (EstateSettings estateSettings in otherEstates)
                         {
-                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
-                            {
-                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
-                                estateSettings.RemoveEstateGroup(user);
-                                Scene.EstateDataService.StoreEstateSettings(estateSettings);
-                            }
+                            if(!isadmin && !estateSettings.IsEstateManagerOrOwner(agentID))
+                                continue;
+                            estateSettings.RemoveEstateGroup(user);
+                            changed[(int)estateSettings.EstateID] = estateSettings;
                         }
                     }
 
-                    Scene.RegionInfo.EstateSettings.RemoveEstateGroup(user);
-                    Scene.EstateDataService.StoreEstateSettings(Scene.RegionInfo.EstateSettings);
+                    thisSettings.RemoveEstateGroup(user);
+                    changed[thisEstateID] = thisSettings;
 
-                    TriggerEstateInfoChange();
-                    remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.AllowedGroups, Scene.RegionInfo.EstateSettings.EstateGroups, Scene.RegionInfo.EstateSettings.EstateID);
-                }
-                else
-                {
-                    remote_client.SendAlertMessage("Method EstateAccessDelta Failed, you don't have permissions");
+                    sendGroups[remote_client] = invoice;
                 }
-            }
 
-            if ((estateAccessType & 64) != 0) // Ban add
-            {
-                if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, false))
+                if ((estateAccessType & 64) != 0) // Ban add
                 {
-                    EstateBan[] banlistcheck = Scene.RegionInfo.EstateSettings.EstateBans;
-
-                    bool alreadyInList = false;
 
-                    for (int i = 0; i < banlistcheck.Length; i++)
+                    if(thisSettings.EstateBansCount() >= (int)Constants.EstateAccessLimits.EstateBans)
                     {
-                        if (user == banlistcheck[i].BannedUserID)
+                        if(!sentBansFull)
                         {
-                            alreadyInList = true;
-                            break;
+                            sentBansFull = true;
+                            remote_client.SendAlertMessage("Estate Ban list is full");
                         }
-
                     }
-                    if (!alreadyInList)
+                    else
                     {
+                        EstateBan[] banlistcheck = Scene.RegionInfo.EstateSettings.EstateBans;
 
-                        if ((estateAccessType & 1) != 0) // All estates
-                        {
-                            List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
-                            EstateSettings estateSettings;
+                        bool alreadyInList = false;
 
-                            foreach (int estateID in estateIDs)
+                        for (int i = 0; i < banlistcheck.Length; i++)
+                        {
+                            if (user == banlistcheck[i].BannedUserID)
+                            {
+                                alreadyInList = true;
+                                break;
+                            }
+                        }
+                        if (!alreadyInList)
+                        {
+                            if (doOtherEstates) // All estates
                             {
-                                if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                                foreach (EstateSettings estateSettings in otherEstates)
                                 {
+                                    if(!isadmin && !estateSettings.IsEstateManagerOrOwner(agentID))
+                                        continue;
+
+                                    if(estateSettings.EstateBansCount() >= (int)Constants.EstateAccessLimits.EstateBans)
+                                        continue;
+
                                     EstateBan bitem = new EstateBan();
 
                                     bitem.BannedUserID = user;
-                                    bitem.EstateID = (uint)estateID;
+                                    bitem.EstateID = estateSettings.EstateID;
                                     bitem.BannedHostAddress = "0.0.0.0";
                                     bitem.BannedHostIPMask = "0.0.0.0";
 
-                                    estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
                                     estateSettings.AddBan(bitem);
-                                    Scene.EstateDataService.StoreEstateSettings(estateSettings);
+                                    estateSettings.RemoveEstateUser(user);
+                                    changed[(int)estateSettings.EstateID] = estateSettings;
                                 }
                             }
-                        }
-
-                        EstateBan item = new EstateBan();
 
-                        item.BannedUserID = user;
-                        item.EstateID = Scene.RegionInfo.EstateSettings.EstateID;
-                        item.BannedHostAddress = "0.0.0.0";
-                        item.BannedHostIPMask = "0.0.0.0";
+                            EstateBan item = new EstateBan();
 
-                        Scene.RegionInfo.EstateSettings.AddBan(item);
-                        Scene.EstateDataService.StoreEstateSettings(Scene.RegionInfo.EstateSettings);
+                            item.BannedUserID = user;
+                            item.EstateID = Scene.RegionInfo.EstateSettings.EstateID;
+                            item.BannedHostAddress = "0.0.0.0";
+                            item.BannedHostIPMask = "0.0.0.0";
 
-                        TriggerEstateInfoChange();
+                            thisSettings.AddBan(item);
+                            thisSettings.RemoveEstateUser(user);
+                            changed[thisEstateID] = thisSettings;
 
-                        ScenePresence s = Scene.GetScenePresence(user);
-                        if (s != null)
-                        {
-                            if (!s.IsChildAgent)
+                            ScenePresence s = Scene.GetScenePresence(user);
+                            if (s != null)
                             {
-                                if (!Scene.TeleportClientHome(user, s.ControllingClient))
+                                if (!s.IsChildAgent)
                                 {
-                                    s.ControllingClient.Kick("Your access to the region was revoked and TP home failed - you have been logged out.");
-                                    Scene.CloseAgent(s.UUID, false);
+                                    if (!Scene.TeleportClientHome(user, s.ControllingClient))
+                                    {
+                                        s.ControllingClient.Kick("Your access to the region was revoked and TP home failed - you have been logged out.");
+                                        Scene.CloseAgent(s.UUID, false);
+                                    }
                                 }
                             }
                         }
-
-                    }
-                    else
-                    {
-                        remote_client.SendAlertMessage("User is already on the region ban list");
+                        else
+                        {
+                            remote_client.SendAlertMessage("User is already on the region ban list");
+                        }
+                        //Scene.RegionInfo.regionBanlist.Add(Manager(user);
+                        if(needReply)
+                            sendAllowedOrBanList[remote_client] = invoice;
                     }
-                    //Scene.RegionInfo.regionBanlist.Add(Manager(user);
-                    remote_client.SendBannedUserList(invoice, Scene.RegionInfo.EstateSettings.EstateBans, Scene.RegionInfo.EstateSettings.EstateID);
                 }
-                else
-                {
-                    remote_client.SendAlertMessage("Method EstateAccessDelta Failed, you don't have permissions");
-                }
-            }
 
-            if ((estateAccessType & 128) != 0) // Ban remove
-            {
-                if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, false))
+                if ((estateAccessType & 128) != 0) // Ban remove
                 {
                     EstateBan[] banlistcheck = Scene.RegionInfo.EstateSettings.EstateBans;
 
@@ -890,104 +1021,90 @@ namespace OpenSim.Region.CoreModules.World.Estate
                     
                     if (alreadyInList && listitem != null)
                     {
-                        if ((estateAccessType & 1) != 0) // All estates
+                        if (doOtherEstates) // All estates
                         {
-                            List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
-                            EstateSettings estateSettings;
-
-                            foreach (int estateID in estateIDs)
+                            foreach (EstateSettings estateSettings in otherEstates)
                             {
-                                if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
-                                {
-                                    estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
-                                    estateSettings.RemoveBan(user);
-                                    Scene.EstateDataService.StoreEstateSettings(estateSettings);
-                                }
+                                if(!isadmin && !estateSettings.IsEstateManagerOrOwner(agentID))
+                                    continue;
+                                estateSettings.RemoveBan(user);
+                                changed[(int)estateSettings.EstateID] = estateSettings;
                             }
                         }
 
-                        Scene.RegionInfo.EstateSettings.RemoveBan(listitem.BannedUserID);
-                        Scene.EstateDataService.StoreEstateSettings(Scene.RegionInfo.EstateSettings);
-
-                        TriggerEstateInfoChange();
+                        thisSettings.RemoveBan(listitem.BannedUserID);
+                        changed[thisEstateID] = thisSettings;
                     }
                     else
                     {
                         remote_client.SendAlertMessage("User is not on the region ban list");
                     }
-                    
-                    //Scene.RegionInfo.regionBanlist.Add(Manager(user);
-                    remote_client.SendBannedUserList(invoice, Scene.RegionInfo.EstateSettings.EstateBans, Scene.RegionInfo.EstateSettings.EstateID);
+
+                    if(needReply)
+                        sendAllowedOrBanList[remote_client] = invoice;
                 }
-                else
+
+                // last the ones only for owners of this region
+                if (!Scene.Permissions.CanIssueEstateCommand(agentID, true))
                 {
-                    remote_client.SendAlertMessage("Method EstateAccessDelta Failed, you don't have permissions");
+                        remote_client.SendAlertMessage("Method EstateAccess Failed, you don't have permissions");
+                        continue;
                 }
-            }
 
-            if ((estateAccessType & 256) != 0) // Manager add
-            {
-                if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true))
+                if ((estateAccessType & 256) != 0) // Manager add
                 {
-                    if ((estateAccessType & 1) != 0) // All estates
+                    if(thisSettings.EstateManagersCount() >= (int)Constants.EstateAccessLimits.EstateManagers)
                     {
-                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
-                        EstateSettings estateSettings;
-
-                        foreach (int estateID in estateIDs)
+                        if(!sentManagersFull)
                         {
-                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
+                            sentManagersFull = true;
+                            remote_client.SendAlertMessage("Estate Managers list is full");
+                         }
+                    }
+                    else
+                    {
+                        if (doOtherEstates) // All estates
+                        {
+                            foreach (EstateSettings estateSettings in otherEstates)
                             {
-                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
+                                if(!isadmin && !estateSettings.IsEstateOwner(agentID)) // redundante check?
+                                    continue;
+                                if(estateSettings.EstateManagersCount() >= (int)Constants.EstateAccessLimits.EstateManagers)
+                                    continue;                           
                                 estateSettings.AddEstateManager(user);
-                                Scene.EstateDataService.StoreEstateSettings(estateSettings);
+                                changed[(int)estateSettings.EstateID] = estateSettings;
                             }
                         }
-                    }
 
-                    Scene.RegionInfo.EstateSettings.AddEstateManager(user);
-                    Scene.EstateDataService.StoreEstateSettings(Scene.RegionInfo.EstateSettings);
+                        thisSettings.AddEstateManager(user);
+                        changed[thisEstateID] = thisSettings;
 
-                    TriggerEstateInfoChange();
-                    remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.EstateManagers, Scene.RegionInfo.EstateSettings.EstateManagers, Scene.RegionInfo.EstateSettings.EstateID);
-                }
-                else
-                {
-                    remote_client.SendAlertMessage("Method EstateAccessDelta Failed, you don't have permissions");
+                        sendManagers[remote_client] = invoice;
+                    }
                 }
-            }
 
-            if ((estateAccessType & 512) != 0) // Manager remove
-            {
-                if (Scene.Permissions.CanIssueEstateCommand(remote_client.AgentId, true))
+                if ((estateAccessType & 512) != 0) // Manager remove
                 {
-                    if ((estateAccessType & 1) != 0) // All estates
+                    if (doOtherEstates) // All estates
                     {
-                        List<int> estateIDs = Scene.EstateDataService.GetEstatesByOwner(Scene.RegionInfo.EstateSettings.EstateOwner);
-                        EstateSettings estateSettings;
-
-                        foreach (int estateID in estateIDs)
+                        foreach (EstateSettings estateSettings in otherEstates)
                         {
-                            if (estateID != Scene.RegionInfo.EstateSettings.EstateID)
-                            {
-                                estateSettings = Scene.EstateDataService.LoadEstateSettings(estateID);
-                                estateSettings.RemoveEstateManager(user);
-                                Scene.EstateDataService.StoreEstateSettings(estateSettings);
-                            }
+                            if(!isadmin && !estateSettings.IsEstateOwner(agentID))
+                                continue;
+
+                            estateSettings.RemoveEstateManager(user);
+                            changed[(int)estateSettings.EstateID] = estateSettings;
                         }
                     }
 
-                    Scene.RegionInfo.EstateSettings.RemoveEstateManager(user);
-                    Scene.EstateDataService.StoreEstateSettings(Scene.RegionInfo.EstateSettings);
+                    thisSettings.RemoveEstateManager(user);
+                    changed[thisEstateID] = thisSettings;
 
-                    TriggerEstateInfoChange();
-                    remote_client.SendEstateList(invoice, (int)Constants.EstateAccessCodex.EstateManagers, Scene.RegionInfo.EstateSettings.EstateManagers, Scene.RegionInfo.EstateSettings.EstateID);
-                }
-                else
-                {
-                    remote_client.SendAlertMessage("Method EstateAccessDelta Failed, you don't have permissions");
+                    sendManagers[remote_client] = invoice;
                 }
             }
+            lock(deltareqLock)
+                runnigDeltaExec = false;
         }
 
         public void HandleOnEstateManageTelehub(IClientAPI client, UUID invoice, UUID senderID, string cmd, uint param1)