*Added all the permission checks to the sceneexternalchecks and modified permission module to follow this.

*This makes permission checking much more modular; allows restrictive and granting module to be made without modifying the existing permission module

5 files changed, 580 insertions, 79 deletions

diff --git a/OpenSim/Region/Environment/Scenes/InnerScene.cs b/OpenSim/Region/Environment/Scenes/InnerScene.cs
index 7ffddb3..2c8c323 100644
--- a/OpenSim/Region/Environment/Scenes/InnerScene.cs
+++ b/OpenSim/Region/Environment/Scenes/InnerScene.cs
@@ -394,7 +394,7 @@ namespace OpenSim.Region.Environment.Scenes
                     if (((SceneObjectGroup)obj).LocalId == objectLocalID)
                     {
                         SceneObjectGroup group = (SceneObjectGroup)obj;
-                        if (m_parentScene.Permissions.CanEditObject(remoteClient.AgentId, obj.UUID))
+                        if (m_parentScene.ExternalChecks.ExternalChecksCanEditScript(obj.UUID, remoteClient.AgentId))
                         {
                             // If the attachment point isn't the same as the one previously used
                             // set it's offset position = 0 so that it appears on the attachment point
@@ -1051,7 +1051,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObjectPosition(remoteClient.AgentId, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.Resize(scale, localID);
                 }
@@ -1062,7 +1062,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObjectPosition(remoteClient.AgentId, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.GroupResize(scale, localID);
                 }
@@ -1098,7 +1098,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObjectPosition(remoteClient.AgentId, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId))
                 {
                     group.UpdateSingleRotation(rot, localID);
                 }
@@ -1116,7 +1116,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObjectPosition(remoteClient.AgentId, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId))
                 {
                     group.UpdateGroupRotation(rot);
                 }
@@ -1135,7 +1135,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObjectPosition(remoteClient.AgentId, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId))
                 {
                     group.UpdateGroupRotation(pos, rot);
                 }
@@ -1148,12 +1148,13 @@ namespace OpenSim.Region.Environment.Scenes
             if (group != null)
             {
                 LLVector3 oldPos = group.AbsolutePosition;
-                if (!m_parentScene.Permissions.CanObjectEntry(remoteClient.AgentId, oldPos, pos) && !group.RootPart.m_IsAttachment)
-                {
+                //FIXME: ObjectEntry is not in ExternalChecks!
+                //if (!m_parentScene.Permissions.CanObjectEntry(remoteClient.AgentId, oldPos, pos) && !group.RootPart.m_IsAttachment)
+                //{
                     group.SendGroupTerseUpdate();
-                    return;
-                }
-                if (m_parentScene.Permissions.CanEditObjectPosition(remoteClient.AgentId, group.UUID) || group.RootPart.m_IsAttachment)
+                    //return;
+                //}
+                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(remoteClient.AgentId, group.UUID) || group.RootPart.m_IsAttachment)
                 {
                     group.UpdateSinglePosition(pos, localID);
                 }
@@ -1179,12 +1180,13 @@ namespace OpenSim.Region.Environment.Scenes
                 }
                 else 
                 {
-                    if (!m_parentScene.Permissions.CanObjectEntry(remoteClient.AgentId, oldPos, pos) && !group.RootPart.m_IsAttachment)
-                    {
+                    //FIXME: ObjectEntry not in ExternalChecks!
+                    //if (!m_parentScene.Permissions.CanObjectEntry(remoteClient.AgentId, oldPos, pos) && !group.RootPart.m_IsAttachment)
+                    //{
                         group.SendGroupTerseUpdate();
-                        return;
-                    }
-                    if (m_parentScene.Permissions.CanEditObjectPosition(remoteClient.AgentId, group.UUID) || group.RootPart.m_IsAttachment)
+                      //  return;
+                    //}
+                        if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId) || group.RootPart.m_IsAttachment)
                     {
                         group.UpdateGroupPosition(pos);
                     }
@@ -1203,7 +1205,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObjectPosition(remoteClient.AgentId, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID,remoteClient.AgentId))
                 {
                     group.UpdateTextureEntry(localID, texture);
                 }
@@ -1221,7 +1223,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObject(remoteClient.AgentId, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.UpdatePrimFlags(localID, (ushort)packet.Type, true, packet.ToBytes());
                 }
@@ -1233,7 +1235,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(objectID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObjectPosition(remoteClient.AgentId, group.UUID))// && PermissionsMngr.)
+                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId))// && PermissionsMngr.)
                 {
                     group.GrabMovement(offset, pos, remoteClient);
                 }
@@ -1255,7 +1257,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(primLocalID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObject(remoteClient.AgentId, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.SetPartName(Util.CleanString(name), primLocalID);
                 }
@@ -1272,7 +1274,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(primLocalID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObject(remoteClient.AgentId, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.SetPartDescription(Util.CleanString(description), primLocalID);
                 }
@@ -1285,7 +1287,7 @@ namespace OpenSim.Region.Environment.Scenes
 
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObject(agentID, group.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID,agentID))
                 {
                     group.UpdateExtraParam(primLocalID, type, inUse, data);
                 }
@@ -1302,7 +1304,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(primLocalID);
             if (group != null)
             {
-                if (m_parentScene.Permissions.CanEditObjectPosition(agentID, group.GetPartsFullID(primLocalID)))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.GetPartsFullID(primLocalID), agentID))
                 {
                     ObjectShapePacket.ObjectDataBlock shapeData = new ObjectShapePacket.ObjectDataBlock();
                     shapeData.ObjectLocalID = shapeBlock.ObjectLocalID;
@@ -1489,11 +1491,11 @@ namespace OpenSim.Region.Environment.Scenes
             // * Asset/DRM permission bit "modify" is enabled
             //use CanEditObjectPosition
 
-            if (IncludeInSearch && m_parentScene.Permissions.CanEditObject(user, objid))
+            if (IncludeInSearch && m_parentScene.ExternalChecks.ExternalChecksCanEditObject(objid, user))
             {
                 obj.AddFlag(LLObject.ObjectFlags.JointWheel);
             }
-            else if (!IncludeInSearch && m_parentScene.Permissions.CanEditObjectPosition(user, objid))
+            else if (!IncludeInSearch && m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(objid,user))
             {
                 obj.RemFlag(LLObject.ObjectFlags.JointWheel);
             }
@@ -1526,7 +1528,7 @@ namespace OpenSim.Region.Environment.Scenes
 
             if (originPrim != null)
             {
-                if (m_parentScene.Permissions.CanCopyObject(AgentID, originPrim.UUID))
+                if (m_parentScene.ExternalChecks.ExternalChecksCanCopyObject(originPrim.Children.Count, originPrim.UUID, AgentID, originPrim.AbsolutePosition))
                 {
                     SceneObjectGroup copy = originPrim.Copy(AgentID, GroupID);
                     copy.AbsolutePosition = copy.AbsolutePosition + offset;
diff --git a/OpenSim/Region/Environment/Scenes/Scene.Inventory.cs b/OpenSim/Region/Environment/Scenes/Scene.Inventory.cs
index b536048..e78ad2b 100644
--- a/OpenSim/Region/Environment/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Environment/Scenes/Scene.Inventory.cs
@@ -73,7 +73,7 @@ namespace OpenSim.Region.Environment.Scenes
                 remoteClient.SendInventoryItemCreateUpdate(item);
 
                 int userlevel = 0;
-                if (Permissions.IsEstateManager(remoteClient.AgentId))
+                if (ExternalChecks.ExternalChecksCanBeGodLike(remoteClient.AgentId))
                 {
                     userlevel = 1;
                 }
@@ -988,13 +988,11 @@ namespace OpenSim.Region.Environment.Scenes
                         bool permission;
                         if (DeRezPacket.AgentBlock.Destination == 1)
                         { // Take Copy
-                            permission = Permissions.CanCopyObject(remoteClient.AgentId, 
-                                                                ((SceneObjectGroup) selectedEnt).UUID);
+                            permission = ExternalChecks.ExternalChecksCanTakeObject(((SceneObjectGroup)selectedEnt).UUID, remoteClient.AgentId);
                         }
                         else
                         { // Take
-                            permission = Permissions.CanDeRezObject(remoteClient.AgentId, 
-                                                                ((SceneObjectGroup) selectedEnt).UUID);
+                            permission = ExternalChecks.ExternalChecksCanTakeObject(((SceneObjectGroup)selectedEnt).UUID, remoteClient.AgentId);
                         }
 
                         if (permission)
@@ -1285,7 +1283,7 @@ namespace OpenSim.Region.Environment.Scenes
                         {
                             string xmlData = Helpers.FieldToUTF8String(rezAsset.Data);                            
                             SceneObjectGroup group = new SceneObjectGroup(this, m_regionHandle, xmlData);
-                            if (!Permissions.CanRezObject(remoteClient.AgentId, pos, group.Children.Count) && !attachment)
+                            if (!ExternalChecks.ExternalChecksCanRezObject(group.Children.Count,remoteClient.AgentId, pos) && !attachment)
                             {
                                 return null;
                             }
@@ -1371,7 +1369,7 @@ namespace OpenSim.Region.Environment.Scenes
                     string xmlData = Helpers.FieldToUTF8String(rezAsset.Data);
                     SceneObjectGroup group = new SceneObjectGroup(this, m_regionHandle, xmlData);
 
-                    if (!Permissions.CanRezObject(ownerID, pos, group.Children.Count))
+                    if (!ExternalChecks.ExternalChecksCanRezObject(group.Children.Count, ownerID, pos))
                     {
                         return null;
                     }
diff --git a/OpenSim/Region/Environment/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Environment/Scenes/Scene.PacketHandlers.cs
index fb043b7..f55d822 100644
--- a/OpenSim/Region/Environment/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Environment/Scenes/Scene.PacketHandlers.cs
@@ -85,7 +85,7 @@ namespace OpenSim.Region.Environment.Scenes
                     if (((SceneObjectGroup) ent).LocalId == primLocalID)
                     {
                         // A prim is only tainted if it's allowed to be edited by the person clicking it.
-                        if (Permissions.CanEditObjectPosition(remoteClient.AgentId, ((SceneObjectGroup)ent).UUID) || Permissions.CanEditObject(remoteClient.AgentId, ((SceneObjectGroup)ent).UUID))
+                        if (ExternalChecks.ExternalChecksCanEditObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId) || ExternalChecks.ExternalChecksCanMoveObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId))
                         {
                             ((SceneObjectGroup) ent).GetProperties(remoteClient);
                             ((SceneObjectGroup) ent).IsSelected = true;
@@ -112,7 +112,7 @@ namespace OpenSim.Region.Environment.Scenes
                 {
                     if (((SceneObjectGroup) ent).LocalId == primLocalID)
                     {
-                        if (Permissions.CanEditObjectPosition(remoteClient.AgentId, ((SceneObjectGroup)ent).UUID) || Permissions.CanEditObject(remoteClient.AgentId, ((SceneObjectGroup)ent).UUID))
+                        if (ExternalChecks.ExternalChecksCanEditObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId) || ExternalChecks.ExternalChecksCanMoveObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId))
                         {
                             ((SceneObjectGroup) ent).IsSelected = false;
                             LandChannel.SetPrimsTainted();
diff --git a/OpenSim/Region/Environment/Scenes/Scene.cs b/OpenSim/Region/Environment/Scenes/Scene.cs
index ebbfece..5ce3c7b 100644
--- a/OpenSim/Region/Environment/Scenes/Scene.cs
+++ b/OpenSim/Region/Environment/Scenes/Scene.cs
@@ -1245,7 +1245,7 @@ namespace OpenSim.Region.Environment.Scenes
            
             LLVector3 pos = GetNewRezLocation(RayStart, RayEnd, RayTargetID, rot, bypassRaycast, RayEndIsIntersection, true, new LLVector3(0.5f,0.5f,0.5f), false);
 
-            if (Permissions.CanRezObject(ownerID, pos, 1))
+            if ( ExternalChecks.ExternalChecksCanRezObject(1,ownerID,pos))
             {
                 // rez ON the ground, not IN the ground
                 pos.Z += 0.25F;
@@ -2519,7 +2519,7 @@ namespace OpenSim.Region.Environment.Scenes
                 if (m_scenePresences.ContainsKey(agentID))
                 {   
                     // First check that this is the sim owner
-                    if (Permissions.GenericEstatePermission(agentID))
+                    if (ExternalChecks.ExternalChecksCanBeGodLike(agentID))
                     {
                         // Next we check for spoofing.....
                         LLUUID testSessionID = m_scenePresences[agentID].ControllingClient.SessionId;
@@ -2597,7 +2597,7 @@ namespace OpenSim.Region.Environment.Scenes
             {
                 if (m_scenePresences.ContainsKey(agentID) || agentID == kickUserID)
                 {
-                    if (Permissions.GenericEstatePermission(godID))
+                    if (ExternalChecks.ExternalChecksCanBeGodLike(godID))
                     {
                         if (agentID == kickUserID)
                         {
@@ -2918,7 +2918,7 @@ namespace OpenSim.Region.Environment.Scenes
                     }
                     else if ((parcel.landData.landFlags & (uint)Parcel.ParcelFlags.AllowGroupScripts) != 0)
                     {
-                        if (part.OwnerID == parcel.landData.ownerID || (parcel.landData.isGroupOwned && part.GroupID == parcel.landData.groupID) || Permissions.GenericEstatePermission(part.OwnerID))
+                        if (part.OwnerID == parcel.landData.ownerID || (parcel.landData.isGroupOwned && part.GroupID == parcel.landData.groupID) || ExternalChecks.ExternalChecksCanBeGodLike(part.OwnerID))
                         {
                             return true;
                         }
diff --git a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs b/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
index 2d3e8e4..4e579b6 100644
--- a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
@@ -30,6 +30,7 @@ using System.Collections.Generic;
 using System.Text;

 using libsecondlife;

 using OpenSim.Framework;

+using OpenSim.Region.Environment.Interfaces;

 

 namespace OpenSim.Region.Environment.Scenes

 {

@@ -42,63 +43,563 @@ namespace OpenSim.Region.Environment.Scenes
             m_scene = scene;

         }

 

-        #region REZ OBJECT

-        public delegate bool CanRezObject(int objectCount, LLUUID owner, IScene scene, LLVector3 objectPosition);

-        private List<CanRezObject> CanRezObjectCheckFunctions = new List<CanRezObject>();

+        #region Object Permission Checks

 

-        public void addCheckRezObject(CanRezObject delegateFunc)

-        {

-            if(!CanRezObjectCheckFunctions.Contains(delegateFunc))

-                CanRezObjectCheckFunctions.Add(delegateFunc);

-        }

-        public void removeCheckRezObject(CanRezObject delegateFunc)

-        {

-            if (CanRezObjectCheckFunctions.Contains(delegateFunc))

-                CanRezObjectCheckFunctions.Remove(delegateFunc);

-        }

+            #region REZ OBJECT

+            public delegate bool CanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition, Scene scene);

+            private List<CanRezObject> CanRezObjectCheckFunctions = new List<CanRezObject>();

 

-        public bool ExternalChecksCanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition)

-        {

-            foreach (CanRezObject check in CanRezObjectCheckFunctions)

+            public void addCheckRezObject(CanRezObject delegateFunc)

+            {

+                if(!CanRezObjectCheckFunctions.Contains(delegateFunc))

+                    CanRezObjectCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckRezObject(CanRezObject delegateFunc)

+            {

+                if (CanRezObjectCheckFunctions.Contains(delegateFunc))

+                    CanRezObjectCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition)

             {

-                if (check(objectCount, owner, m_scene, objectPosition) == false)

+                foreach (CanRezObject check in CanRezObjectCheckFunctions)

                 {

-                    return false;

+                    if (check(objectCount, owner,objectPosition, m_scene) == false)

+                    {

+                        return false;

+                    }

                 }

+                return true;

             }

-            return true;

-        }

+

+            #endregion

+

+            #region DEREZ OBJECT

+            public delegate bool CanDeRezObject(LLUUID objectID, LLUUID deleter, Scene scene);

+            private List<CanDeRezObject> CanDeRezObjectCheckFunctions = new List<CanDeRezObject>();

+

+            public void addCheckDeRezObject(CanDeRezObject delegateFunc)

+            {

+                if (!CanDeRezObjectCheckFunctions.Contains(delegateFunc))

+                    CanDeRezObjectCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckDeRezObject(CanDeRezObject delegateFunc)

+            {

+                if (CanDeRezObjectCheckFunctions.Contains(delegateFunc))

+                    CanDeRezObjectCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanDeRezObject(LLUUID objectID, LLUUID deleter)

+            {

+                foreach (CanDeRezObject check in CanDeRezObjectCheckFunctions)

+                {

+                    if (check(objectID,deleter,m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region TAKE OBJECT

+            public delegate bool CanTakeObject(LLUUID objectID, LLUUID stealer, Scene scene);

+            private List<CanTakeObject> CanTakeObjectCheckFunctions = new List<CanTakeObject>();

+

+            public void addCheckTakeObject(CanTakeObject delegateFunc)

+            {

+                if (!CanTakeObjectCheckFunctions.Contains(delegateFunc))

+                    CanTakeObjectCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckTakeObject(CanTakeObject delegateFunc)

+            {

+                if (CanTakeObjectCheckFunctions.Contains(delegateFunc))

+                    CanTakeObjectCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanTakeObject(LLUUID objectID, LLUUID stealer)

+            {

+                foreach (CanTakeObject check in CanTakeObjectCheckFunctions)

+                {

+                    if (check(objectID, stealer, m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region COPY OBJECT

+            public delegate bool CanCopyObject(int objectCount, LLUUID objectID, LLUUID owner, Scene scene, LLVector3 objectPosition);

+            private List<CanCopyObject> CanCopyObjectCheckFunctions = new List<CanCopyObject>();

+

+            public void addCheckCopyObject(CanCopyObject delegateFunc)

+            {

+                if (!CanCopyObjectCheckFunctions.Contains(delegateFunc))

+                    CanCopyObjectCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckCopyObject(CanCopyObject delegateFunc)

+            {

+                if (CanCopyObjectCheckFunctions.Contains(delegateFunc))

+                    CanCopyObjectCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanCopyObject(int objectCount, LLUUID objectID, LLUUID owner, LLVector3 objectPosition)

+            {

+                foreach (CanCopyObject check in CanCopyObjectCheckFunctions)

+                {

+                    if (check(objectCount, objectID, owner, m_scene, objectPosition) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region EDIT OBJECT

+            public delegate bool CanEditObject(LLUUID objectID, LLUUID editorID, Scene scene);

+            private List<CanEditObject> CanEditObjectCheckFunctions = new List<CanEditObject>();

+

+            public void addCheckEditObject(CanEditObject delegateFunc)

+            {

+                if (!CanEditObjectCheckFunctions.Contains(delegateFunc))

+                    CanEditObjectCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckEditObject(CanEditObject delegateFunc)

+            {

+                if (CanEditObjectCheckFunctions.Contains(delegateFunc))

+                    CanEditObjectCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanEditObject(LLUUID objectID, LLUUID editorID)

+            {

+                foreach (CanEditObject check in CanEditObjectCheckFunctions)

+                {

+                    if (check(objectID, editorID, m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region MOVE OBJECT

+            public delegate bool CanMoveObject(LLUUID objectID, LLUUID moverID, Scene scene);

+            private List<CanMoveObject> CanMoveObjectCheckFunctions = new List<CanMoveObject>();

+

+            public void addCheckMoveObject(CanMoveObject delegateFunc)

+            {

+                if (!CanMoveObjectCheckFunctions.Contains(delegateFunc))

+                    CanMoveObjectCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckMoveObject(CanMoveObject delegateFunc)

+            {

+                if (CanMoveObjectCheckFunctions.Contains(delegateFunc))

+                    CanMoveObjectCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanMoveObject(LLUUID objectID, LLUUID moverID)

+            {

+                foreach (CanMoveObject check in CanMoveObjectCheckFunctions)

+                {

+                    if (check(objectID,moverID,m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region RETURN OBJECT

+            public delegate bool CanReturnObject(LLUUID objectID, LLUUID returnerID, Scene scene);

+            private List<CanReturnObject> CanReturnObjectCheckFunctions = new List<CanReturnObject>();

+

+            public void addCheckReturnObject(CanReturnObject delegateFunc)

+            {

+                if (!CanReturnObjectCheckFunctions.Contains(delegateFunc))

+                    CanReturnObjectCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckReturnObject(CanReturnObject delegateFunc)

+            {

+                if (CanReturnObjectCheckFunctions.Contains(delegateFunc))

+                    CanReturnObjectCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanReturnObject(LLUUID objectID, LLUUID returnerID)

+            {

+                foreach (CanReturnObject check in CanReturnObjectCheckFunctions)

+                {

+                    if (check(objectID,returnerID,m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

 

         #endregion

 

-        #region RUN SCRIPT

-        public delegate bool CanRunScript(LLUUID script, LLUUID owner, IScene scene);

-        private List<CanRunScript> CanRunScriptCheckFunctions = new List<CanRunScript>();

+        #region Misc Permission Checks

 

-        public void addCheckRunScript(CanRunScript delegateFunc)

-        {

-            if (!CanRunScriptCheckFunctions.Contains(delegateFunc))

-                CanRunScriptCheckFunctions.Add(delegateFunc);

-        }

-        public void removeCheckRunScript(CanRunScript delegateFunc)

-        {

-            if (CanRunScriptCheckFunctions.Contains(delegateFunc))

-                CanRunScriptCheckFunctions.Remove(delegateFunc);

-        }

+            #region INSTANT MESSAGE

+            public delegate bool CanInstantMessage(LLUUID user, LLUUID target, Scene startScene);

+            private List<CanInstantMessage> CanInstantMessageCheckFunctions = new List<CanInstantMessage>();

 

-        public bool ExternalChecksCanRunScript(LLUUID script, LLUUID owner)

-        {

-            foreach (CanRunScript check in CanRunScriptCheckFunctions)

+            public void addCheckInstantMessage(CanInstantMessage delegateFunc)

+            {

+                if (!CanInstantMessageCheckFunctions.Contains(delegateFunc))

+                    CanInstantMessageCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckInstantMessage(CanInstantMessage delegateFunc)

+            {

+                if (CanInstantMessageCheckFunctions.Contains(delegateFunc))

+                    CanInstantMessageCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanInstantMessage(LLUUID user, LLUUID target)

             {

-                if (check(script,owner,m_scene) == false)

+                foreach (CanInstantMessage check in CanInstantMessageCheckFunctions)

                 {

-                    return false;

+                    if (check(user,target,m_scene) == false)

+                    {

+                        return false;

+                    }

                 }

+                return true;

             }

-            return true;

-        }

+

+            #endregion

+

+            #region INVENTORY TRANSFER

+            public delegate bool CanInventoryTransfer(LLUUID user, LLUUID target, Scene startScene);

+            private List<CanInventoryTransfer> CanInventoryTransferCheckFunctions = new List<CanInventoryTransfer>();

+

+            public void addCheckInventoryTransfer(CanInventoryTransfer delegateFunc)

+            {

+                if (!CanInventoryTransferCheckFunctions.Contains(delegateFunc))

+                    CanInventoryTransferCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckInventoryTransfer(CanInventoryTransfer delegateFunc)

+            {

+                if (CanInventoryTransferCheckFunctions.Contains(delegateFunc))

+                    CanInventoryTransferCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanInventoryTransfer(LLUUID user, LLUUID target)

+            {

+                foreach (CanInventoryTransfer check in CanInventoryTransferCheckFunctions)

+                {

+                    if (check(user, target, m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region EDIT SCRIPT

+            public delegate bool CanEditScript(LLUUID script, LLUUID user, Scene scene);

+            private List<CanEditScript> CanEditScriptCheckFunctions = new List<CanEditScript>();

+

+            public void addCheckEditScript(CanEditScript delegateFunc)

+            {

+                if (!CanEditScriptCheckFunctions.Contains(delegateFunc))

+                    CanEditScriptCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckEditScript(CanEditScript delegateFunc)

+            {

+                if (CanEditScriptCheckFunctions.Contains(delegateFunc))

+                    CanEditScriptCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanEditScript(LLUUID script, LLUUID user)

+            {

+                foreach (CanEditScript check in CanEditScriptCheckFunctions)

+                {

+                    if (check(script, user, m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region RUN SCRIPT

+            public delegate bool CanRunScript(LLUUID script, LLUUID user, Scene scene);

+            private List<CanRunScript> CanRunScriptCheckFunctions = new List<CanRunScript>();

+

+            public void addCheckRunScript(CanRunScript delegateFunc)

+            {

+                if (!CanRunScriptCheckFunctions.Contains(delegateFunc))

+                    CanRunScriptCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckRunScript(CanRunScript delegateFunc)

+            {

+                if (CanRunScriptCheckFunctions.Contains(delegateFunc))

+                    CanRunScriptCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanRunScript(LLUUID script, LLUUID user)

+            {

+                foreach (CanRunScript check in CanRunScriptCheckFunctions)

+                {

+                    if (check(script, user, m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region TERRAFORM LAND

+            public delegate bool CanTerraformLandCommand(LLUUID user, LLVector3 position, Scene requestFromScene);

+            private List<CanTerraformLandCommand> CanTerraformLandCommandCheckFunctions = new List<CanTerraformLandCommand>();

+

+            public void addCheckTerraformLandCommand(CanTerraformLandCommand delegateFunc)

+            {

+                if (!CanTerraformLandCommandCheckFunctions.Contains(delegateFunc))

+                    CanTerraformLandCommandCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckTerraformLandCommand(CanTerraformLandCommand delegateFunc)

+            {

+                if (CanTerraformLandCommandCheckFunctions.Contains(delegateFunc))

+                    CanTerraformLandCommandCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanTerraformLand(LLUUID user, LLVector3 pos)

+            {

+                foreach (CanTerraformLandCommand check in CanTerraformLandCommandCheckFunctions)

+                {

+                    if (check(user, pos, m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region RUN CONSOLE COMMAND

+            public delegate bool CanRunConsoleCommand(LLUUID user, Scene requestFromScene);

+            private List<CanRunConsoleCommand> CanRunConsoleCommandCheckFunctions = new List<CanRunConsoleCommand>();

+

+            public void addCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)

+            {

+                if (!CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))

+                    CanRunConsoleCommandCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)

+            {

+                if (CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))

+                    CanRunConsoleCommandCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanRunConsoleCommand(LLUUID user)

+            {

+                foreach (CanRunConsoleCommand check in CanRunConsoleCommandCheckFunctions)

+                {

+                    if (check(user, m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

+

+            #region CAN BE GODLIKE

+            public delegate bool CanBeGodLike(LLUUID user, Scene requestFromScene);

+            private List<CanBeGodLike> CanBeGodLikeCheckFunctions = new List<CanBeGodLike>();

+

+            public void addCheckBeGodLike(CanBeGodLike delegateFunc)

+            {

+                if (!CanBeGodLikeCheckFunctions.Contains(delegateFunc))

+                    CanBeGodLikeCheckFunctions.Add(delegateFunc);

+            }

+            public void removeCheckBeGodLike(CanBeGodLike delegateFunc)

+            {

+                if (CanBeGodLikeCheckFunctions.Contains(delegateFunc))

+                    CanBeGodLikeCheckFunctions.Remove(delegateFunc);

+            }

+

+            public bool ExternalChecksCanBeGodLike(LLUUID user)

+            {

+                foreach (CanBeGodLike check in CanBeGodLikeCheckFunctions)

+                {

+                    if (check(user, m_scene) == false)

+                    {

+                        return false;

+                    }

+                }

+                return true;

+            }

+

+            #endregion

 

         #endregion

 

+        #region Parcel and Estate Permission Checks

+                #region EDIT ESTATE TERRAIN

+                public delegate bool CanEditEstateTerrain(LLUUID user, Scene scene);

+                    private List<CanEditEstateTerrain> CanEditEstateTerrainCheckFunctions = new List<CanEditEstateTerrain>();

+

+                    public void addCheckEditEstateTerrain(CanEditEstateTerrain delegateFunc)

+                    {

+                        if (!CanEditEstateTerrainCheckFunctions.Contains(delegateFunc))

+                            CanEditEstateTerrainCheckFunctions.Add(delegateFunc);

+                    }

+                    public void removeCheckEditEstateTerrain(CanEditEstateTerrain delegateFunc)

+                    {

+                        if (CanEditEstateTerrainCheckFunctions.Contains(delegateFunc))

+                            CanEditEstateTerrainCheckFunctions.Remove(delegateFunc);

+                    }

+

+                    public bool ExternalChecksCanEditEstateTerrain(LLUUID user)

+                    {

+                        foreach (CanEditEstateTerrain check in CanEditEstateTerrainCheckFunctions)

+                        {

+                            if (check(user, m_scene) == false)

+                            {

+                                return false;

+                            }

+                        }

+                        return true;

+                    }

+

+                #endregion

+

+                #region RESTART SIM

+                public delegate bool CanRestartSim(LLUUID user, Scene scene);

+                private List<CanRestartSim> CanRestartSimCheckFunctions = new List<CanRestartSim>();

+

+                public void addCheckRestartSim(CanRestartSim delegateFunc)

+                {

+                    if (!CanRestartSimCheckFunctions.Contains(delegateFunc))

+                        CanRestartSimCheckFunctions.Add(delegateFunc);

+                }

+                public void removeCheckRestartSim(CanRestartSim delegateFunc)

+                {

+                    if (CanRestartSimCheckFunctions.Contains(delegateFunc))

+                        CanRestartSimCheckFunctions.Remove(delegateFunc);

+                }

+

+                public bool ExternalChecksCanRestartSim(LLUUID user)

+                {

+                    foreach (CanRestartSim check in CanRestartSimCheckFunctions)

+                    {

+                        if (check(user, m_scene) == false)

+                        {

+                            return false;

+                        }

+                    }

+                    return true;

+                }

+            #endregion

+

+                #region EDIT PARCEL

+                    public delegate bool CanEditParcel(LLUUID user, ILandObject parcel, Scene scene);

+                    private List<CanEditParcel> CanEditParcelCheckFunctions = new List<CanEditParcel>();

+

+                    public void addCheckEditParcel(CanEditParcel delegateFunc)

+                    {

+                        if (!CanEditParcelCheckFunctions.Contains(delegateFunc))

+                            CanEditParcelCheckFunctions.Add(delegateFunc);

+                    }

+                    public void removeCheckEditParcel(CanEditParcel delegateFunc)

+                    {

+                        if (CanEditParcelCheckFunctions.Contains(delegateFunc))

+                            CanEditParcelCheckFunctions.Remove(delegateFunc);

+                    }

+

+                    public bool ExternalChecksCanEditParcel(LLUUID user, ILandObject parcel)

+                    {

+                        foreach (CanEditParcel check in CanEditParcelCheckFunctions)

+                        {

+                            if (check(user, parcel, m_scene) == false)

+                            {

+                                return false;

+                            }

+                        }

+                        return true;

+                    }

+                #endregion

+

+                #region SELL PARCEL

+                    public delegate bool CanSellParcel(LLUUID user, ILandObject parcel, Scene scene);

+                    private List<CanSellParcel> CanSellParcelCheckFunctions = new List<CanSellParcel>();

+

+                    public void addCheckSellParcel(CanSellParcel delegateFunc)

+                    {

+                        if (!CanSellParcelCheckFunctions.Contains(delegateFunc))

+                            CanSellParcelCheckFunctions.Add(delegateFunc);

+                    }

+                    public void removeCheckSellParcel(CanSellParcel delegateFunc)

+                    {

+                        if (CanSellParcelCheckFunctions.Contains(delegateFunc))

+                            CanSellParcelCheckFunctions.Remove(delegateFunc);

+                    }

+

+                    public bool ExternalChecksCanSellParcel(LLUUID user, ILandObject parcel)

+                    {

+                        foreach (CanSellParcel check in CanSellParcelCheckFunctions)

+                        {

+                            if (check(user, parcel, m_scene) == false)

+                            {

+                                return false;

+                            }

+                        }

+                        return true;

+                    }

+                #endregion

+

+                #region ABANDON PARCEL

+                    public delegate bool CanAbandonParcel(LLUUID user, ILandObject parcel, Scene scene);

+                    private List<CanAbandonParcel> CanAbandonParcelCheckFunctions = new List<CanAbandonParcel>();

+

+                    public void addCheckAbandonParcel(CanAbandonParcel delegateFunc)

+                    {

+                        if (!CanAbandonParcelCheckFunctions.Contains(delegateFunc))

+                            CanAbandonParcelCheckFunctions.Add(delegateFunc);

+                    }

+                    public void removeCheckAbandonParcel(CanAbandonParcel delegateFunc)

+                    {

+                        if (CanAbandonParcelCheckFunctions.Contains(delegateFunc))

+                            CanAbandonParcelCheckFunctions.Remove(delegateFunc);

+                    }

+

+                    public bool ExternalChecksCanAbandonParcel(LLUUID user, ILandObject parcel)

+                    {

+                        foreach (CanAbandonParcel check in CanAbandonParcelCheckFunctions)

+                        {

+                            if (check(user, parcel, m_scene) == false)

+                            {

+                                return false;

+                            }

+                        }

+                        return true;

+                    }

+                #endregion

+            #endregion

+

+

     }

 }