chance new effective permissions code to ease aggregation on demand( ie on changes). But still doing full aggregation on checks, so still heavy

1 files changed, 89 insertions, 109 deletions

diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
index f44604b..7b9ea8b 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.Inventory.cs
@@ -259,41 +259,11 @@ namespace OpenSim.Region.Framework.Scenes
                 // this can't be done here but on every place where a change may happen (rez, (de)link, contents , perms,  etc)
                 // bc this is on heavy duty code paths
                 // but for now we need to test the concept
-                AggregateEveryOnePerms();
+                AggregateDeepPerms();
                 return m_EffectiveEveryOnePerms;
             }
         }
 
-        public void AggregateEveryOnePerms()
-        {
-            lock(PermissionsLock)
-            {
-                // get object everyone permissions
-                uint baseperms = RootPart.EveryoneMask & (uint)PermissionMask.All;
-
-                if(baseperms == 0)
-                {
-                    m_EffectiveEveryOnePerms = 0;
-                    return;
-                }
-                
-                uint current = baseperms;
-                SceneObjectPart[] parts = m_parts.GetArray();
-                for (int i = 0; i < parts.Length; i++)
-                {
-                    SceneObjectPart part = parts[i];
-                    part.Inventory.AggregateEveryOnePerms(ref current);
-                    if( current == 0)
-                        break;
-                }
-                // recover move
-                baseperms &= (uint)PermissionMask.Move;
-                current |= baseperms;
-                current &= (uint)PermissionMask.All;
-                m_EffectiveEveryOnePerms = current;
-            }
-        }
-
         private uint m_EffectiveGroupPerms;
         public uint EffectiveGroupPerms
         {
@@ -302,126 +272,136 @@ namespace OpenSim.Region.Framework.Scenes
                 // this can't be done here but on every place where a change may happen (rez, (de)link, contents , perms,  etc)
                 // bc this is on heavy duty code paths
                 // but for now we need to test the concept
-                AggregateGroupPerms();
+                AggregateDeepPerms();
                 return m_EffectiveGroupPerms;
             }
         }
 
-        public void AggregateGroupPerms()
+        public uint EffectiveGroupOrEveryOnePerms
         {
-            lock(PermissionsLock)
+            get
             {
-                // get object everyone permissions
-                uint baseperms = RootPart.GroupMask & (uint)PermissionMask.All;
-
-                if(baseperms == 0)
-                {
-                    m_EffectiveGroupPerms = 0;
-                    return;
-                }
-                
-                uint current = baseperms;
-                SceneObjectPart[] parts = m_parts.GetArray();
-                for (int i = 0; i < parts.Length; i++)
-                {
-                    SceneObjectPart part = parts[i];
-                    part.Inventory.AggregateGroupPerms(ref current);
-                    if( current == 0)
-                        break;
-                }
-                // recover modify and move
-                baseperms &= (uint)(PermissionMask.Move | PermissionMask.Modify );
-                current |= baseperms;
-                current &= (uint)PermissionMask.All;
-                m_EffectiveGroupPerms = current;
+                // this can't be done here but on every place where a change may happen (rez, (de)link, contents , perms,  etc)
+                // bc this is on heavy duty code paths
+                // but for now we need to test the concept
+                AggregateDeepPerms();
+                return m_EffectiveEveryOnePerms | m_EffectiveGroupPerms;
             }
         }
 
-        private uint m_EffectiveGroupOrEveryOnePerms;
-        public uint EffectiveGroupOrEveryOnePerms
+        private uint m_EffectiveOwnerPerms;
+        public uint EffectiveOwnerPerms
         {
             get
             {
                 // this can't be done here but on every place where a change may happen (rez, (de)link, contents , perms,  etc)
                 // bc this is on heavy duty code paths
                 // but for now we need to test the concept
-                AggregateGroupOrEveryOnePerms();
-                return m_EffectiveGroupOrEveryOnePerms;
+                AggregateDeepPerms();
+                return m_EffectiveOwnerPerms;
             }
         }
 
-        public void AggregateGroupOrEveryOnePerms()
+        // aggregates perms scanning parts and their contents
+        public void AggregateDeepPerms()
         {
             lock(PermissionsLock)
             {
-                // get object everyone permissions
-                uint baseperms = (RootPart.EveryoneMask | RootPart.GroupMask) & (uint)PermissionMask.All;
+                // aux
+                const uint allmask = (uint)PermissionMask.AllEffective;
+                const uint movemodmask = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                const uint copytransfermast = (uint)(PermissionMask.Copy | PermissionMask.Transfer);
+
+                uint baseOwnerPerms = RootPart.OwnerMask;
+                uint owner = baseOwnerPerms;
+                uint baseGroupPerms = RootPart.GroupMask;
+                uint group = baseGroupPerms;
+                uint baseEveryonePerms = RootPart.EveryoneMask;
+                uint everyone = baseEveryonePerms;
 
-                if(baseperms == 0)
-                {
-                    m_EffectiveGroupOrEveryOnePerms = 0;
-                    return;
-                }
-                
-                uint current = baseperms;
                 SceneObjectPart[] parts = m_parts.GetArray();
                 for (int i = 0; i < parts.Length; i++)
                 {
                     SceneObjectPart part = parts[i];
-                    part.Inventory.AggregateGroupOrEveryonePerms(ref current);
-                    if( current == 0)
-                        break;
+                    part.AggregateInnerPerms();
+                    owner &= part.AggregatedInnerOwnerPerms; 
+                    group &= part.AggregatedInnerGroupPerms;
+                    everyone &= part.AggregatedInnerEveryonePerms;
                 }
                 // recover modify and move
-                baseperms &= (uint)(PermissionMask.Move | PermissionMask.Modify );
-                current |= baseperms;
-                current &= (uint)PermissionMask.All;
-                m_EffectiveGroupOrEveryOnePerms = current;
-            }
-        }
+                baseOwnerPerms &= movemodmask;
+                owner |= baseOwnerPerms;
+                if((owner & copytransfermast) == 0)
+                    owner |= (uint)PermissionMask.Transfer;
+                owner &= allmask;
+                m_EffectiveOwnerPerms = owner;
 
-        private uint m_EffectiveOwnerPerms;
-        public uint EffectiveOwnerPerms
-        {
-            get
-            {
-                // this can't be done here but on every place where a change may happen (rez, (de)link, contents , perms,  etc)
-                // bc this is on heavy duty code paths
-                // but for now we need to test the concept
-                AggregateOwnerPerms();
-                return m_EffectiveOwnerPerms;
+                // recover modify and move
+                baseGroupPerms &= movemodmask;
+                group |= baseGroupPerms;
+                if((group & copytransfermast) == 0)
+                    group |= (uint)PermissionMask.Transfer;
+                group &= allmask;
+                m_EffectiveGroupPerms = group;
+
+                // recover move
+                baseEveryonePerms &= (uint)PermissionMask.Move;
+                everyone |= baseEveryonePerms;
+                if((everyone & copytransfermast) == 0) // not much sense but as sl
+                    everyone |= (uint)PermissionMask.Transfer;
+                everyone &= allmask;
+                m_EffectiveEveryOnePerms = everyone;
             }
         }
 
-        public void AggregateOwnerPerms()
+        // aggregates perms scanning parts, assuming their contents was already aggregated
+        public void AggregatePerms()
         {
             lock(PermissionsLock)
             {
-                // get object everyone permissions
-                uint baseperms = RootPart.OwnerMask  & (uint)PermissionMask.All;
+                // aux
+                const uint allmask = (uint)PermissionMask.AllEffective;
+                const uint movemodmask = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                const uint copytransfermast = (uint)(PermissionMask.Copy | PermissionMask.Transfer);
+
+                uint baseOwnerPerms = RootPart.OwnerMask;
+                uint owner = baseOwnerPerms;
+                uint baseGroupPerms = RootPart.GroupMask;
+                uint group = baseGroupPerms;
+                uint baseEveryonePerms = RootPart.EveryoneMask;
+                uint everyone = baseEveryonePerms;
 
-                if(baseperms == 0)
-                {
-                    m_EffectiveOwnerPerms = 0;
-                    return;
-                }
-                
-                uint current = baseperms;
                 SceneObjectPart[] parts = m_parts.GetArray();
                 for (int i = 0; i < parts.Length; i++)
                 {
                     SceneObjectPart part = parts[i];
-                    part.Inventory.AggregateOwnerPerms(ref current);
-                    if( current == 0)
-                        break;
+                    owner &= part.AggregatedInnerOwnerPerms; 
+                    group &= part.AggregatedInnerGroupPerms;
+                    everyone &= part.AggregatedInnerEveryonePerms;
                 }
                 // recover modify and move
-                baseperms &= (uint)(PermissionMask.Move | PermissionMask.Modify );
-                current |= baseperms;
-                current &= (uint)PermissionMask.All;
-                if((current & (uint)(PermissionMask.Copy | PermissionMask.Transfer)) == 0)
-                    current |= (uint)PermissionMask.Transfer;
-                m_EffectiveOwnerPerms = current;
+                baseOwnerPerms &= movemodmask;
+                owner |= baseOwnerPerms;
+                if((owner & copytransfermast) == 0)
+                    owner |= (uint)PermissionMask.Transfer;
+                owner &= allmask;
+                m_EffectiveOwnerPerms = owner;
+
+                // recover modify and move
+                baseGroupPerms &= movemodmask;
+                group |= baseGroupPerms;
+                if((group & copytransfermast) == 0)
+                    group |= (uint)PermissionMask.Transfer;
+                group &= allmask;
+                m_EffectiveGroupPerms = group;
+
+                // recover move
+                baseEveryonePerms &= (uint)PermissionMask.Move;
+                everyone |= baseEveryonePerms;
+                if((everyone & copytransfermast) == 0) // not much sense but as sl
+                    everyone |= (uint)PermissionMask.Transfer;
+                everyone &= allmask;
+                m_EffectiveEveryOnePerms = everyone;
             }
         }