Refactor: Scene.ExternalChecks -> Scene.Permissions. Also make all

the internals of the permissions module adapter sane

13 files changed, 348 insertions, 348 deletions

diff --git a/OpenSim/Region/Environment/Scenes/Scene.Inventory.cs b/OpenSim/Region/Environment/Scenes/Scene.Inventory.cs
index 686f4ba..9b30d87 100644
--- a/OpenSim/Region/Environment/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Environment/Scenes/Scene.Inventory.cs
@@ -105,7 +105,7 @@ namespace OpenSim.Region.Environment.Scenes
                 userInfo.AddItem(item);
 
                 int userlevel = 0;
-                if (ExternalChecks.ExternalChecksCanBeGodLike(AgentID))
+                if (Permissions.IsGod(AgentID))
                 {
                     userlevel = 1;
                 }
@@ -171,7 +171,7 @@ namespace OpenSim.Region.Environment.Scenes
                     {
                         if ((InventoryType) item.InvType == InventoryType.Notecard)
                         {
-                            if (!ExternalChecks.ExternalChecksCanEditNotecard(itemID, UUID.Zero, remoteClient.AgentId))
+                            if (!Permissions.CanEditNotecard(itemID, UUID.Zero, remoteClient.AgentId))
                             {
                                 remoteClient.SendAgentAlertMessage("Insufficient permissions to edit notecard", false);
                                 return UUID.Zero;
@@ -180,7 +180,7 @@ namespace OpenSim.Region.Environment.Scenes
                         }
                         else if ((InventoryType) item.InvType == InventoryType.LSL)
                         {
-                            if (!ExternalChecks.ExternalChecksCanEditScript(itemID, UUID.Zero, remoteClient.AgentId))
+                            if (!Permissions.CanEditScript(itemID, UUID.Zero, remoteClient.AgentId))
                             {
                                 remoteClient.SendAgentAlertMessage("Insufficient permissions to edit script", false);
                                 return UUID.Zero;
@@ -243,7 +243,7 @@ namespace OpenSim.Region.Environment.Scenes
         public void CapsUpdateTaskInventoryScriptAsset(IClientAPI remoteClient, UUID itemId,
                                                        UUID primId, bool isScriptRunning, byte[] data)
         {
-            if (!ExternalChecks.ExternalChecksCanEditScript(itemId, primId, remoteClient.AgentId))
+            if (!Permissions.CanEditScript(itemId, primId, remoteClient.AgentId))
             {
                 remoteClient.SendAgentAlertMessage("Insufficient permissions to edit script", false);
                 return;
@@ -432,7 +432,7 @@ namespace OpenSim.Region.Environment.Scenes
 
                 if (item != null)
                 {
-                    if (!ExternalChecks.ExternalChecksBypassPermissions())
+                    if (!Permissions.BypassPermissions())
                     {
                         if ((item.CurrentPermissions & (uint)PermissionMask.Transfer) == 0)
                             return null;
@@ -458,7 +458,7 @@ namespace OpenSim.Region.Environment.Scenes
                         itemCopy.AssetType = item.AssetType;
                         itemCopy.InvType = item.InvType;
                         itemCopy.Folder = UUID.Zero;
-                        if (ExternalChecks.ExternalChecksPropagatePermissions())
+                        if (Permissions.PropagatePermissions())
                         {
                             if (item.InvType == 6)
                             {
@@ -500,7 +500,7 @@ namespace OpenSim.Region.Environment.Scenes
 
                         recipientUserInfo.AddItem(itemCopy);
 
-                        if (!ExternalChecks.ExternalChecksBypassPermissions())
+                        if (!Permissions.BypassPermissions())
                         {
                             if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
                                 senderUserInfo.DeleteItem(itemId);
@@ -764,7 +764,7 @@ namespace OpenSim.Region.Environment.Scenes
         {
             m_log.DebugFormat("[AGENT INVENTORY]: Received request to create inventory item {0} in folder {1}", name, folderID);
 
-            if (!ExternalChecks.ExternalChecksCanCreateUserInventory(invType, remoteClient.AgentId))
+            if (!Permissions.CanCreateUserInventory(invType, remoteClient.AgentId))
                 return;
                 
             if (transactionID == UUID.Zero)
@@ -975,7 +975,7 @@ namespace OpenSim.Region.Environment.Scenes
             agentItem.InvType = taskItem.InvType;
             agentItem.Flags = taskItem.Flags;
 
-            if ((destAgent != taskItem.OwnerID) && ExternalChecks.ExternalChecksPropagatePermissions())
+            if ((destAgent != taskItem.OwnerID) && Permissions.PropagatePermissions())
             {
                 agentItem.BasePermissions = taskItem.NextPermissions;
                 agentItem.CurrentPermissions = taskItem.NextPermissions | 8;
@@ -992,7 +992,7 @@ namespace OpenSim.Region.Environment.Scenes
                 agentItem.GroupPermissions = taskItem.GroupPermissions;
             }
 
-            if (!ExternalChecks.ExternalChecksBypassPermissions())
+            if (!Permissions.BypassPermissions())
             {
                 if ((taskItem.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
                     part.Inventory.RemoveInventoryItem(itemId);
@@ -1165,7 +1165,7 @@ namespace OpenSim.Region.Environment.Scenes
 
             if (destPart.OwnerID != part.OwnerID)
             {
-                if (ExternalChecks.ExternalChecksPropagatePermissions())
+                if (Permissions.PropagatePermissions())
                 {
                     destTaskItem.CurrentPermissions = srcTaskItem.CurrentPermissions &
                             srcTaskItem.NextPermissions;
@@ -1262,7 +1262,7 @@ namespace OpenSim.Region.Environment.Scenes
                 // AllowInventoryDrop flag has been set. Don't however let
                 // them update an item unless they pass the external checks
                 //
-                if (!ExternalChecks.ExternalChecksCanEditObjectInventory(part.UUID, remoteClient.AgentId)
+                if (!Permissions.CanEditObjectInventory(part.UUID, remoteClient.AgentId)
                     && (currentItem != null || !allowInventoryDrop))
                     return;
 
@@ -1291,7 +1291,7 @@ namespace OpenSim.Region.Environment.Scenes
                                     "[PRIM INVENTORY]: Update with item {0} requested of prim {1} for {2}",
                                     item.Name, primLocalID, remoteClient.Name);
                                 part.GetProperties(remoteClient);
-                                if (!ExternalChecks.ExternalChecksBypassPermissions())
+                                if (!Permissions.BypassPermissions())
                                 {
                                     if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
                                         RemoveInventoryItem(remoteClient, itemID);
@@ -1358,7 +1358,7 @@ namespace OpenSim.Region.Environment.Scenes
                         SceneObjectPart part = GetSceneObjectPart(localID);
                         if (part != null)
                         {
-                            if (!ExternalChecks.ExternalChecksCanEditObjectInventory(part.UUID, remoteClient.AgentId))
+                            if (!Permissions.CanEditObjectInventory(part.UUID, remoteClient.AgentId))
                                 return;
 
                             part.ParentGroup.AddInventoryItem(remoteClient, localID, item, copyID);
@@ -1400,7 +1400,7 @@ namespace OpenSim.Region.Environment.Scenes
                 if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
                     return;
                 
-                if (!ExternalChecks.ExternalChecksCanCreateObjectInventory(
+                if (!Permissions.CanCreateObjectInventory(
                     itemBase.InvType, part.UUID, remoteClient.AgentId))               
                     return;             
 
@@ -1506,7 +1506,7 @@ namespace OpenSim.Region.Environment.Scenes
 
             if (destPart.OwnerID != srcPart.OwnerID)
             {
-                if (ExternalChecks.ExternalChecksPropagatePermissions())
+                if (Permissions.PropagatePermissions())
                 {
                     destTaskItem.CurrentPermissions = srcTaskItem.CurrentPermissions &
                             srcTaskItem.NextPermissions;
@@ -1567,20 +1567,20 @@ namespace OpenSim.Region.Environment.Scenes
             if (destination == 1) // Take Copy
             {
                 permissionToTake =
-                        ExternalChecks.ExternalChecksCanTakeCopyObject(
+                        Permissions.CanTakeCopyObject(
                         grp.UUID,
                         remoteClient.AgentId);
             }
             else if (destination == 5) // God take copy
             {
                 permissionToTake =
-                        ExternalChecks.ExternalChecksCanBeGodLike(
+                        Permissions.IsGod(
                         remoteClient.AgentId);
             }
             else if (destination == 4) // Take
             {
                 permissionToTake =
-                        ExternalChecks.ExternalChecksCanTakeObject(
+                        Permissions.CanTakeObject(
                         grp.UUID,
                         remoteClient.AgentId);
 
@@ -1590,11 +1590,11 @@ namespace OpenSim.Region.Environment.Scenes
             else if (destination == 6) //Delete
             {
                 permissionToTake =
-                        ExternalChecks.ExternalChecksCanDeleteObject(
+                        Permissions.CanDeleteObject(
                         grp.UUID,
                         remoteClient.AgentId);
                 permissionToDelete =
-                        ExternalChecks.ExternalChecksCanDeleteObject(
+                        Permissions.CanDeleteObject(
                         grp.UUID,
                         remoteClient.AgentId);
             }
@@ -1603,11 +1603,11 @@ namespace OpenSim.Region.Environment.Scenes
                 if (remoteClient != null)
                 {
                     permissionToTake =
-                            ExternalChecks.ExternalChecksCanDeleteObject(
+                            Permissions.CanDeleteObject(
                             grp.UUID,
                             remoteClient.AgentId);
                     permissionToDelete =
-                            ExternalChecks.ExternalChecksCanDeleteObject(
+                            Permissions.CanDeleteObject(
                             grp.UUID,
                             remoteClient.AgentId);
                     if (permissionToDelete)
@@ -1722,7 +1722,7 @@ namespace OpenSim.Region.Environment.Scenes
                 item.InvType = (int)InventoryType.Object;
                 item.Folder = folderID;
                 
-                if (remoteClient != null && (remoteClient.AgentId != objectGroup.RootPart.OwnerID) && ExternalChecks.ExternalChecksPropagatePermissions())
+                if (remoteClient != null && (remoteClient.AgentId != objectGroup.RootPart.OwnerID) && Permissions.PropagatePermissions())
                 {
                     uint perms=objectGroup.GetEffectivePermissions();
                     uint nextPerms=(perms & 7) << 13;
@@ -1877,7 +1877,7 @@ namespace OpenSim.Region.Environment.Scenes
 
                     item.Folder = UUID.Zero; // Objects folder!
 
-                    if ((remoteClient.AgentId != grp.RootPart.OwnerID) && ExternalChecks.ExternalChecksPropagatePermissions())
+                    if ((remoteClient.AgentId != grp.RootPart.OwnerID) && Permissions.PropagatePermissions())
                     {
                         item.BasePermissions = grp.RootPart.NextOwnerMask;
                         item.CurrentPermissions = grp.RootPart.NextOwnerMask;
@@ -1988,7 +1988,7 @@ namespace OpenSim.Region.Environment.Scenes
                         {
                             string xmlData = Utils.BytesToString(rezAsset.Data);
                             SceneObjectGroup group = new SceneObjectGroup(xmlData, true);
-                            if (!ExternalChecks.ExternalChecksCanRezObject(
+                            if (!Permissions.CanRezObject(
                                 group.Children.Count, remoteClient.AgentId, pos) 
                                 && !attachment)
                             {
@@ -2043,7 +2043,7 @@ namespace OpenSim.Region.Environment.Scenes
                                 rootPart.ObjectSaleType = 0;
                                 rootPart.SalePrice = 10;
 
-                                if (ExternalChecks.ExternalChecksPropagatePermissions())
+                                if (Permissions.PropagatePermissions())
                                 {
                                     if ((item.CurrentPermissions & 8) != 0)
                                     {
@@ -2093,7 +2093,7 @@ namespace OpenSim.Region.Environment.Scenes
                             if (!attachment)
                                 rootPart.ScheduleFullUpdate();
 
-                            if (!ExternalChecks.ExternalChecksBypassPermissions())
+                            if (!Permissions.BypassPermissions())
                             {
                                 if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
                                     userInfo.DeleteItem(item.ID);
@@ -2133,7 +2133,7 @@ namespace OpenSim.Region.Environment.Scenes
                     string xmlData = Utils.BytesToString(rezAsset.Data);
                     SceneObjectGroup group = new SceneObjectGroup(xmlData, true);
 
-                    if (!ExternalChecks.ExternalChecksCanRezObject(group.Children.Count, ownerID, pos))
+                    if (!Permissions.CanRezObject(group.Children.Count, ownerID, pos))
                     {
                         return null;
                     }
@@ -2158,7 +2158,7 @@ namespace OpenSim.Region.Environment.Scenes
 
                     if (rootPart.OwnerID != item.OwnerID)
                     {
-                        if (ExternalChecks.ExternalChecksPropagatePermissions())
+                        if (Permissions.PropagatePermissions())
                         {
                             if ((item.CurrentPermissions & 8) != 0)
                             {
@@ -2197,7 +2197,7 @@ namespace OpenSim.Region.Environment.Scenes
                     group.CreateScriptInstances(param, true, DefaultScriptEngine, 2);
                     rootPart.ScheduleFullUpdate();
 
-                    if (!ExternalChecks.ExternalChecksBypassPermissions())
+                    if (!Permissions.BypassPermissions())
                     {
                         if ((item.CurrentPermissions & (uint)PermissionMask.Copy) == 0)
                             sourcePart.Inventory.RemoveInventoryItem(item.ItemID);
@@ -2315,7 +2315,7 @@ namespace OpenSim.Region.Environment.Scenes
             ScenePresence presence;
             if (TryGetAvatar(remoteClient.AgentId, out presence))
             {
-                if (!ExternalChecks.ExternalChecksCanRezObject(part.ParentGroup.Children.Count, remoteClient.AgentId, presence.AbsolutePosition))
+                if (!Permissions.CanRezObject(part.ParentGroup.Children.Count, remoteClient.AgentId, presence.AbsolutePosition))
                     return;
 
                 presence.Appearance.DetachAttachment(itemID);
@@ -2359,7 +2359,7 @@ namespace OpenSim.Region.Environment.Scenes
 
         void ObjectOwner(IClientAPI remoteClient, UUID ownerID, UUID groupID, List<uint> localIDs)
         {
-            if (!ExternalChecks.ExternalChecksCanBeGodLike(remoteClient.AgentId))
+            if (!Permissions.IsGod(remoteClient.AgentId))
                 return;
 
             foreach (uint localID in localIDs)
diff --git a/OpenSim/Region/Environment/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Environment/Scenes/Scene.PacketHandlers.cs
index c9c7bef..97846cf 100644
--- a/OpenSim/Region/Environment/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Environment/Scenes/Scene.PacketHandlers.cs
@@ -113,8 +113,8 @@ namespace OpenSim.Region.Environment.Scenes
                         ((SceneObjectGroup) ent).GetProperties(remoteClient);
                         ((SceneObjectGroup) ent).IsSelected = true;
                         // A prim is only tainted if it's allowed to be edited by the person clicking it.
-                        if (ExternalChecks.ExternalChecksCanEditObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId) 
-                            || ExternalChecks.ExternalChecksCanMoveObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId))
+                        if (Permissions.CanEditObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId) 
+                            || Permissions.CanMoveObject(((SceneObjectGroup)ent).UUID, remoteClient.AgentId))
                         {
                             EventManager.TriggerParcelPrimCountTainted();
                         }
@@ -181,9 +181,9 @@ namespace OpenSim.Region.Environment.Scenes
             //
             if (!isAttachment)
             {
-                if (ExternalChecks.ExternalChecksCanEditObject(
+                if (Permissions.CanEditObject(
                         part.UUID, remoteClient.AgentId) 
-                        || ExternalChecks.ExternalChecksCanMoveObject(
+                        || Permissions.CanMoveObject(
                         part.UUID, remoteClient.AgentId))
                     EventManager.TriggerParcelPrimCountTainted();
             }
@@ -337,7 +337,7 @@ namespace OpenSim.Region.Environment.Scenes
             if (part == null)
                 return;
 
-            if (ExternalChecks.ExternalChecksCanResetScript(itemID, remoteClient.AgentId))
+            if (Permissions.CanResetScript(itemID, remoteClient.AgentId))
             {
                 EventManager.TriggerScriptReset(part.LocalId, itemID);
             }
diff --git a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs b/OpenSim/Region/Environment/Scenes/Scene.Permissions.cs
index 0977734..3a5a3d1 100644
--- a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
+++ b/OpenSim/Region/Environment/Scenes/Scene.Permissions.cs
@@ -34,33 +34,33 @@ using OpenSim.Region.Environment.Interfaces;
 
 namespace OpenSim.Region.Environment.Scenes
 {
-    public class SceneExternalChecks
+    public class ScenePermissions
     {
         private Scene m_scene;
 
-        public SceneExternalChecks(Scene scene)
+        public ScenePermissions(Scene scene)
         {
             m_scene = scene;
         }
 
         #region Object Permission Checks
 
-        public delegate uint GenerateClientFlags(UUID userID, UUID objectIDID);
-        private List<GenerateClientFlags> GenerateClientFlagsCheckFunctions = new List<GenerateClientFlags>();
+        public delegate uint GenerateClientFlagsHandler(UUID userID, UUID objectIDID);
+        private List<GenerateClientFlagsHandler> GenerateClientFlagsCheckFunctions = new List<GenerateClientFlagsHandler>();
 
-        public void addGenerateClientFlags(GenerateClientFlags delegateFunc)
+        public void AddGenerateClientFlagsHandler(GenerateClientFlagsHandler delegateFunc)
         {
             if (!GenerateClientFlagsCheckFunctions.Contains(delegateFunc))
                 GenerateClientFlagsCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeGenerateClientFlags(GenerateClientFlags delegateFunc)
+        public void RemoveGenerateClientFlagsHandler(GenerateClientFlagsHandler delegateFunc)
         {
             if (GenerateClientFlagsCheckFunctions.Contains(delegateFunc))
                 GenerateClientFlagsCheckFunctions.Remove(delegateFunc);
         }
 
-        public uint ExternalChecksGenerateClientFlags(UUID userID, UUID objectID)
+        public uint GenerateClientFlags(UUID userID, UUID objectID)
         {
             SceneObjectPart part=m_scene.GetSceneObjectPart(objectID);
 
@@ -81,54 +81,54 @@ namespace OpenSim.Region.Environment.Scenes
                 (uint)PrimFlags.ObjectYouOfficer;
             #pragma warning restore 0612
 
-            foreach (GenerateClientFlags check in GenerateClientFlagsCheckFunctions)
+            foreach (GenerateClientFlagsHandler check in GenerateClientFlagsCheckFunctions)
             {
                 perms &= check(userID, objectID);
             }
             return perms;
         }
 
-        public delegate void SetBypassPermissions(bool value);
-        private List<SetBypassPermissions> SetBypassPermissionsCheckFunctions = new List<SetBypassPermissions>();
+        public delegate void SetBypassPermissionsHandler(bool value);
+        private List<SetBypassPermissionsHandler> SetBypassPermissionsCheckFunctions = new List<SetBypassPermissionsHandler>();
 
-        public void addSetBypassPermissions(SetBypassPermissions delegateFunc)
+        public void AddSetBypassPermissionsHandler(SetBypassPermissionsHandler delegateFunc)
         {
             if (!SetBypassPermissionsCheckFunctions.Contains(delegateFunc))
                 SetBypassPermissionsCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeSetBypassPermissions(SetBypassPermissions delegateFunc)
+        public void RemoveSetBypassPermissionsHandler(SetBypassPermissionsHandler delegateFunc)
         {
             if (SetBypassPermissionsCheckFunctions.Contains(delegateFunc))
                 SetBypassPermissionsCheckFunctions.Remove(delegateFunc);
         }
 
-        public void ExternalChecksSetBypassPermissions(bool value)
+        public void SetBypassPermissions(bool value)
         {
-            foreach (SetBypassPermissions check in SetBypassPermissionsCheckFunctions)
+            foreach (SetBypassPermissionsHandler check in SetBypassPermissionsCheckFunctions)
             {
                 check(value);
             }
         }
 
-        public delegate bool BypassPermissions();
-        private List<BypassPermissions> BypassPermissionsCheckFunctions = new List<BypassPermissions>();
+        public delegate bool BypassPermissionsHandler();
+        private List<BypassPermissionsHandler> BypassPermissionsCheckFunctions = new List<BypassPermissionsHandler>();
 
-        public void addBypassPermissions(BypassPermissions delegateFunc)
+        public void AddBypassPermissionsHandler(BypassPermissionsHandler delegateFunc)
         {
             if (!BypassPermissionsCheckFunctions.Contains(delegateFunc))
                 BypassPermissionsCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeBypassPermissions(BypassPermissions delegateFunc)
+        public void RemoveBypassPermissionsHandler(BypassPermissionsHandler delegateFunc)
         {
             if (BypassPermissionsCheckFunctions.Contains(delegateFunc))
                 BypassPermissionsCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksBypassPermissions()
+        public bool BypassPermissions()
         {
-            foreach (BypassPermissions check in BypassPermissionsCheckFunctions)
+            foreach (BypassPermissionsHandler check in BypassPermissionsCheckFunctions)
             {
                 if (check() == false)
                 {
@@ -138,24 +138,24 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }
 
-        public delegate bool PropagatePermissions();
-        private List<PropagatePermissions> PropagatePermissionsCheckFunctions = new List<PropagatePermissions>();
+        public delegate bool PropagatePermissionsHandler();
+        private List<PropagatePermissionsHandler> PropagatePermissionsCheckFunctions = new List<PropagatePermissionsHandler>();
 
-        public void addPropagatePermissions(PropagatePermissions delegateFunc)
+        public void AddPropagatePermissionsHandler(PropagatePermissionsHandler delegateFunc)
         {
             if (!PropagatePermissionsCheckFunctions.Contains(delegateFunc))
                 PropagatePermissionsCheckFunctions.Add(delegateFunc);
         }
 
-        public void removePropagatePermissions(PropagatePermissions delegateFunc)
+        public void RemovePropagatePermissionsHandler(PropagatePermissionsHandler delegateFunc)
         {
             if (PropagatePermissionsCheckFunctions.Contains(delegateFunc))
                 PropagatePermissionsCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksPropagatePermissions()
+        public bool PropagatePermissions()
         {
-            foreach (PropagatePermissions check in PropagatePermissionsCheckFunctions)
+            foreach (PropagatePermissionsHandler check in PropagatePermissionsCheckFunctions)
             {
                 if (check() == false)
                 {
@@ -166,24 +166,24 @@ namespace OpenSim.Region.Environment.Scenes
         }
 
         #region REZ OBJECT
-        public delegate bool CanRezObject(int objectCount, UUID owner, Vector3 objectPosition, Scene scene);
-        private List<CanRezObject> CanRezObjectCheckFunctions = new List<CanRezObject>();
+        public delegate bool CanRezObjectHandler(int objectCount, UUID owner, Vector3 objectPosition, Scene scene);
+        private List<CanRezObjectHandler> CanRezObjectCheckFunctions = new List<CanRezObjectHandler>();
 
-        public void addCheckRezObject(CanRezObject delegateFunc)
+        public void AddRezObjectHandler(CanRezObjectHandler delegateFunc)
         {
             if (!CanRezObjectCheckFunctions.Contains(delegateFunc))
                 CanRezObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckRezObject(CanRezObject delegateFunc)
+        public void RemoveRezObjectHandler(CanRezObjectHandler delegateFunc)
         {
             if (CanRezObjectCheckFunctions.Contains(delegateFunc))
                 CanRezObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanRezObject(int objectCount, UUID owner, Vector3 objectPosition)
+        public bool CanRezObject(int objectCount, UUID owner, Vector3 objectPosition)
         {
-            foreach (CanRezObject check in CanRezObjectCheckFunctions)
+            foreach (CanRezObjectHandler check in CanRezObjectCheckFunctions)
             {
                 if (check(objectCount, owner,objectPosition, m_scene) == false)
                 {
@@ -196,24 +196,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region DELETE OBJECT
-        public delegate bool CanDeleteObject(UUID objectID, UUID deleter, Scene scene);
-        private List<CanDeleteObject> CanDeleteObjectCheckFunctions = new List<CanDeleteObject>();
+        public delegate bool CanDeleteObjectHandler(UUID objectID, UUID deleter, Scene scene);
+        private List<CanDeleteObjectHandler> CanDeleteObjectCheckFunctions = new List<CanDeleteObjectHandler>();
 
-        public void addCheckDeleteObject(CanDeleteObject delegateFunc)
+        public void AddDeleteObjectHandler(CanDeleteObjectHandler delegateFunc)
         {
             if (!CanDeleteObjectCheckFunctions.Contains(delegateFunc))
                 CanDeleteObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckDeleteObject(CanDeleteObject delegateFunc)
+        public void RemoveDeleteObjectHandler(CanDeleteObjectHandler delegateFunc)
         {
             if (CanDeleteObjectCheckFunctions.Contains(delegateFunc))
                 CanDeleteObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanDeleteObject(UUID objectID, UUID deleter)
+        public bool CanDeleteObject(UUID objectID, UUID deleter)
         {
-            foreach (CanDeleteObject check in CanDeleteObjectCheckFunctions)
+            foreach (CanDeleteObjectHandler check in CanDeleteObjectCheckFunctions)
             {
                 if (check(objectID,deleter,m_scene) == false)
                 {
@@ -226,24 +226,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region TAKE OBJECT
-        public delegate bool CanTakeObject(UUID objectID, UUID stealer, Scene scene);
-        private List<CanTakeObject> CanTakeObjectCheckFunctions = new List<CanTakeObject>();
+        public delegate bool CanTakeObjectHandler(UUID objectID, UUID stealer, Scene scene);
+        private List<CanTakeObjectHandler> CanTakeObjectCheckFunctions = new List<CanTakeObjectHandler>();
 
-        public void addCheckTakeObject(CanTakeObject delegateFunc)
+        public void AddTakeObjectHandler(CanTakeObjectHandler delegateFunc)
         {
             if (!CanTakeObjectCheckFunctions.Contains(delegateFunc))
                 CanTakeObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckTakeObject(CanTakeObject delegateFunc)
+        public void RemoveTakeObjectHandler(CanTakeObjectHandler delegateFunc)
         {
             if (CanTakeObjectCheckFunctions.Contains(delegateFunc))
                 CanTakeObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanTakeObject(UUID objectID, UUID AvatarTakingUUID)
+        public bool CanTakeObject(UUID objectID, UUID AvatarTakingUUID)
         {
-            foreach (CanTakeObject check in CanTakeObjectCheckFunctions)
+            foreach (CanTakeObjectHandler check in CanTakeObjectCheckFunctions)
             {
                 if (check(objectID, AvatarTakingUUID, m_scene) == false)
                 {
@@ -256,24 +256,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region TAKE COPY OBJECT
-        public delegate bool CanTakeCopyObject(UUID objectID, UUID userID, Scene inScene);
-        private List<CanTakeCopyObject> CanTakeCopyObjectCheckFunctions = new List<CanTakeCopyObject>();
+        public delegate bool CanTakeCopyObjectHandler(UUID objectID, UUID userID, Scene inScene);
+        private List<CanTakeCopyObjectHandler> CanTakeCopyObjectCheckFunctions = new List<CanTakeCopyObjectHandler>();
 
-        public void addCheckTakeCopyObject(CanTakeCopyObject delegateFunc)
+        public void AddTakeCopyObjectHandler(CanTakeCopyObjectHandler delegateFunc)
         {
             if (!CanTakeCopyObjectCheckFunctions.Contains(delegateFunc))
                 CanTakeCopyObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckTakeCopyObject(CanTakeCopyObject delegateFunc)
+        public void RemoveTakeCopyObjectHandler(CanTakeCopyObjectHandler delegateFunc)
         {
             if (CanTakeCopyObjectCheckFunctions.Contains(delegateFunc))
                 CanTakeCopyObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanTakeCopyObject(UUID objectID, UUID userID)
+        public bool CanTakeCopyObject(UUID objectID, UUID userID)
         {
-            foreach (CanTakeCopyObject check in CanTakeCopyObjectCheckFunctions)
+            foreach (CanTakeCopyObjectHandler check in CanTakeCopyObjectCheckFunctions)
             {
                 if (check(objectID,userID,m_scene) == false)
                 {
@@ -286,24 +286,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region DUPLICATE OBJECT
-        public delegate bool CanDuplicateObject(int objectCount, UUID objectID, UUID owner, Scene scene, Vector3 objectPosition);
-        private List<CanDuplicateObject> CanDuplicateObjectCheckFunctions = new List<CanDuplicateObject>();
+        public delegate bool CanDuplicateObjectHandler(int objectCount, UUID objectID, UUID owner, Scene scene, Vector3 objectPosition);
+        private List<CanDuplicateObjectHandler> CanDuplicateObjectCheckFunctions = new List<CanDuplicateObjectHandler>();
 
-        public void addCheckDuplicateObject(CanDuplicateObject delegateFunc)
+        public void AddDuplicateObjectHandler(CanDuplicateObjectHandler delegateFunc)
         {
             if (!CanDuplicateObjectCheckFunctions.Contains(delegateFunc))
                 CanDuplicateObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckDuplicateObject(CanDuplicateObject delegateFunc)
+        public void RemoveDuplicateObjectHandler(CanDuplicateObjectHandler delegateFunc)
         {
             if (CanDuplicateObjectCheckFunctions.Contains(delegateFunc))
                 CanDuplicateObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanDuplicateObject(int objectCount, UUID objectID, UUID owner, Vector3 objectPosition)
+        public bool CanDuplicateObject(int objectCount, UUID objectID, UUID owner, Vector3 objectPosition)
         {
-            foreach (CanDuplicateObject check in CanDuplicateObjectCheckFunctions)
+            foreach (CanDuplicateObjectHandler check in CanDuplicateObjectCheckFunctions)
             {
                 if (check(objectCount, objectID, owner, m_scene, objectPosition) == false)
                 {
@@ -316,24 +316,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region EDIT OBJECT
-        public delegate bool CanEditObject(UUID objectID, UUID editorID, Scene scene);
-        private List<CanEditObject> CanEditObjectCheckFunctions = new List<CanEditObject>();
+        public delegate bool CanEditObjectHandler(UUID objectID, UUID editorID, Scene scene);
+        private List<CanEditObjectHandler> CanEditObjectCheckFunctions = new List<CanEditObjectHandler>();
 
-        public void addCheckEditObject(CanEditObject delegateFunc)
+        public void AddEditObjectHandler(CanEditObjectHandler delegateFunc)
         {
             if (!CanEditObjectCheckFunctions.Contains(delegateFunc))
                 CanEditObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckEditObject(CanEditObject delegateFunc)
+        public void RemoveEditObjectHandler(CanEditObjectHandler delegateFunc)
         {
             if (CanEditObjectCheckFunctions.Contains(delegateFunc))
                 CanEditObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanEditObject(UUID objectID, UUID editorID)
+        public bool CanEditObject(UUID objectID, UUID editorID)
         {
-            foreach (CanEditObject check in CanEditObjectCheckFunctions)
+            foreach (CanEditObjectHandler check in CanEditObjectCheckFunctions)
             {
                 if (check(objectID, editorID, m_scene) == false)
                 {
@@ -343,24 +343,24 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }
 
-        public delegate bool CanEditObjectInventory(UUID objectID, UUID editorID, Scene scene);
-        private List<CanEditObjectInventory> CanEditObjectInventoryCheckFunctions = new List<CanEditObjectInventory>();
+        public delegate bool CanEditObjectInventoryHandler(UUID objectID, UUID editorID, Scene scene);
+        private List<CanEditObjectInventoryHandler> CanEditObjectInventoryCheckFunctions = new List<CanEditObjectInventoryHandler>();
 
-        public void addCheckEditObjectInventory(CanEditObjectInventory delegateFunc)
+        public void AddEditObjectInventoryHandler(CanEditObjectInventoryHandler delegateFunc)
         {
             if (!CanEditObjectInventoryCheckFunctions.Contains(delegateFunc))
                 CanEditObjectInventoryCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckEditObjectInventory(CanEditObjectInventory delegateFunc)
+        public void RemoveEditObjectInventoryHandler(CanEditObjectInventoryHandler delegateFunc)
         {
             if (CanEditObjectInventoryCheckFunctions.Contains(delegateFunc))
                 CanEditObjectInventoryCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanEditObjectInventory(UUID objectID, UUID editorID)
+        public bool CanEditObjectInventory(UUID objectID, UUID editorID)
         {
-            foreach (CanEditObjectInventory check in CanEditObjectInventoryCheckFunctions)
+            foreach (CanEditObjectInventoryHandler check in CanEditObjectInventoryCheckFunctions)
             {
                 if (check(objectID, editorID, m_scene) == false)
                 {
@@ -373,24 +373,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region MOVE OBJECT
-        public delegate bool CanMoveObject(UUID objectID, UUID moverID, Scene scene);
-        private List<CanMoveObject> CanMoveObjectCheckFunctions = new List<CanMoveObject>();
+        public delegate bool CanMoveObjectHandler(UUID objectID, UUID moverID, Scene scene);
+        private List<CanMoveObjectHandler> CanMoveObjectCheckFunctions = new List<CanMoveObjectHandler>();
 
-        public void addCheckMoveObject(CanMoveObject delegateFunc)
+        public void AddMoveObjectHandler(CanMoveObjectHandler delegateFunc)
         {
             if (!CanMoveObjectCheckFunctions.Contains(delegateFunc))
                 CanMoveObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckMoveObject(CanMoveObject delegateFunc)
+        public void RemoveMoveObjectHandler(CanMoveObjectHandler delegateFunc)
         {
             if (CanMoveObjectCheckFunctions.Contains(delegateFunc))
                 CanMoveObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanMoveObject(UUID objectID, UUID moverID)
+        public bool CanMoveObject(UUID objectID, UUID moverID)
         {
-            foreach (CanMoveObject check in CanMoveObjectCheckFunctions)
+            foreach (CanMoveObjectHandler check in CanMoveObjectCheckFunctions)
             {
                 if (check(objectID,moverID,m_scene) == false)
                 {
@@ -403,24 +403,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region OBJECT ENTRY
-        public delegate bool CanObjectEntry(UUID objectID, Vector3 newPoint, Scene scene);
-        private List<CanObjectEntry> CanObjectEntryCheckFunctions = new List<CanObjectEntry>();
+        public delegate bool CanObjectEntryHandler(UUID objectID, Vector3 newPoint, Scene scene);
+        private List<CanObjectEntryHandler> CanObjectEntryCheckFunctions = new List<CanObjectEntryHandler>();
 
-        public void addCheckObjectEntry(CanObjectEntry delegateFunc)
+        public void AddObjectEntryHandler(CanObjectEntryHandler delegateFunc)
         {
             if (!CanObjectEntryCheckFunctions.Contains(delegateFunc))
                 CanObjectEntryCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckObjectEntry(CanObjectEntry delegateFunc)
+        public void RemoveObjectEntryHandler(CanObjectEntryHandler delegateFunc)
         {
             if (CanObjectEntryCheckFunctions.Contains(delegateFunc))
                 CanObjectEntryCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanObjectEntry(UUID objectID, Vector3 newPoint)
+        public bool CanObjectEntry(UUID objectID, Vector3 newPoint)
         {
-            foreach (CanObjectEntry check in CanObjectEntryCheckFunctions)
+            foreach (CanObjectEntryHandler check in CanObjectEntryCheckFunctions)
             {
                 if (check(objectID, newPoint, m_scene) == false)
                 {
@@ -433,24 +433,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region RETURN OBJECT
-        public delegate bool CanReturnObject(UUID objectID, UUID returnerID, Scene scene);
-        private List<CanReturnObject> CanReturnObjectCheckFunctions = new List<CanReturnObject>();
+        public delegate bool CanReturnObjectHandler(UUID objectID, UUID returnerID, Scene scene);
+        private List<CanReturnObjectHandler> CanReturnObjectCheckFunctions = new List<CanReturnObjectHandler>();
 
-        public void addCheckReturnObject(CanReturnObject delegateFunc)
+        public void AddReturnObjectHandler(CanReturnObjectHandler delegateFunc)
         {
             if (!CanReturnObjectCheckFunctions.Contains(delegateFunc))
                 CanReturnObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckReturnObject(CanReturnObject delegateFunc)
+        public void RemoveReturnObjectHandler(CanReturnObjectHandler delegateFunc)
         {
             if (CanReturnObjectCheckFunctions.Contains(delegateFunc))
                 CanReturnObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanReturnObject(UUID objectID, UUID returnerID)
+        public bool CanReturnObject(UUID objectID, UUID returnerID)
         {
-            foreach (CanReturnObject check in CanReturnObjectCheckFunctions)
+            foreach (CanReturnObjectHandler check in CanReturnObjectCheckFunctions)
             {
                 if (check(objectID,returnerID,m_scene) == false)
                 {
@@ -463,24 +463,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region INSTANT MESSAGE
-        public delegate bool CanInstantMessage(UUID user, UUID target, Scene startScene);
-        private List<CanInstantMessage> CanInstantMessageCheckFunctions = new List<CanInstantMessage>();
+        public delegate bool CanInstantMessageHandler(UUID user, UUID target, Scene startScene);
+        private List<CanInstantMessageHandler> CanInstantMessageCheckFunctions = new List<CanInstantMessageHandler>();
 
-        public void addCheckInstantMessage(CanInstantMessage delegateFunc)
+        public void AddInstantMessageHandler(CanInstantMessageHandler delegateFunc)
         {
             if (!CanInstantMessageCheckFunctions.Contains(delegateFunc))
                 CanInstantMessageCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckInstantMessage(CanInstantMessage delegateFunc)
+        public void RemoveInstantMessageHandler(CanInstantMessageHandler delegateFunc)
         {
             if (CanInstantMessageCheckFunctions.Contains(delegateFunc))
                 CanInstantMessageCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanInstantMessage(UUID user, UUID target)
+        public bool CanInstantMessage(UUID user, UUID target)
         {
-            foreach (CanInstantMessage check in CanInstantMessageCheckFunctions)
+            foreach (CanInstantMessageHandler check in CanInstantMessageCheckFunctions)
             {
                 if (check(user, target, m_scene) == false)
                 {
@@ -493,24 +493,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region INVENTORY TRANSFER
-        public delegate bool CanInventoryTransfer(UUID user, UUID target, Scene startScene);
-        private List<CanInventoryTransfer> CanInventoryTransferCheckFunctions = new List<CanInventoryTransfer>();
+        public delegate bool CanInventoryTransferHandler(UUID user, UUID target, Scene startScene);
+        private List<CanInventoryTransferHandler> CanInventoryTransferCheckFunctions = new List<CanInventoryTransferHandler>();
 
-        public void addCheckInventoryTransfer(CanInventoryTransfer delegateFunc)
+        public void AddInventoryTransferHandler(CanInventoryTransferHandler delegateFunc)
         {
             if (!CanInventoryTransferCheckFunctions.Contains(delegateFunc))
                 CanInventoryTransferCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckInventoryTransfer(CanInventoryTransfer delegateFunc)
+        public void RemoveInventoryTransferHandler(CanInventoryTransferHandler delegateFunc)
             {
                 if (CanInventoryTransferCheckFunctions.Contains(delegateFunc))
                     CanInventoryTransferCheckFunctions.Remove(delegateFunc);
             }
 
-        public bool ExternalChecksCanInventoryTransfer(UUID user, UUID target)
+        public bool CanInventoryTransfer(UUID user, UUID target)
         {
-            foreach (CanInventoryTransfer check in CanInventoryTransferCheckFunctions)
+            foreach (CanInventoryTransferHandler check in CanInventoryTransferCheckFunctions)
             {
                 if (check(user, target, m_scene) == false)
                 {
@@ -523,24 +523,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region VIEW SCRIPT
-        public delegate bool CanViewScript(UUID script, UUID objectID, UUID user, Scene scene);
-        private List<CanViewScript> CanViewScriptCheckFunctions = new List<CanViewScript>();
+        public delegate bool CanViewScriptHandler(UUID script, UUID objectID, UUID user, Scene scene);
+        private List<CanViewScriptHandler> CanViewScriptCheckFunctions = new List<CanViewScriptHandler>();
 
-        public void addCheckViewScript(CanViewScript delegateFunc)
+        public void AddViewScriptHandler(CanViewScriptHandler delegateFunc)
         {
             if (!CanViewScriptCheckFunctions.Contains(delegateFunc))
                 CanViewScriptCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckViewScript(CanViewScript delegateFunc)
+        public void RemoveViewScriptHandler(CanViewScriptHandler delegateFunc)
         {
             if (CanViewScriptCheckFunctions.Contains(delegateFunc))
                 CanViewScriptCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanViewScript(UUID script, UUID objectID, UUID user)
+        public bool CanViewScript(UUID script, UUID objectID, UUID user)
         {
-            foreach (CanViewScript check in CanViewScriptCheckFunctions)
+            foreach (CanViewScriptHandler check in CanViewScriptCheckFunctions)
             {
                 if (check(script, objectID, user, m_scene) == false)
                 {
@@ -550,24 +550,24 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }
 
-        public delegate bool CanViewNotecard(UUID script, UUID objectID, UUID user, Scene scene);
-        private List<CanViewNotecard> CanViewNotecardCheckFunctions = new List<CanViewNotecard>();
+        public delegate bool CanViewNotecardHandler(UUID script, UUID objectID, UUID user, Scene scene);
+        private List<CanViewNotecardHandler> CanViewNotecardCheckFunctions = new List<CanViewNotecardHandler>();
 
-        public void addCheckViewNotecard(CanViewNotecard delegateFunc)
+        public void AddViewNotecardHandler(CanViewNotecardHandler delegateFunc)
         {
             if (!CanViewNotecardCheckFunctions.Contains(delegateFunc))
                 CanViewNotecardCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckViewNotecard(CanViewNotecard delegateFunc)
+        public void RemoveViewNotecardHandler(CanViewNotecardHandler delegateFunc)
         {
             if (CanViewNotecardCheckFunctions.Contains(delegateFunc))
                 CanViewNotecardCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanViewNotecard(UUID script, UUID objectID, UUID user)
+        public bool CanViewNotecard(UUID script, UUID objectID, UUID user)
         {
-            foreach (CanViewNotecard check in CanViewNotecardCheckFunctions)
+            foreach (CanViewNotecardHandler check in CanViewNotecardCheckFunctions)
             {
                 if (check(script, objectID, user, m_scene) == false)
                 {
@@ -580,24 +580,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region EDIT SCRIPT
-        public delegate bool CanEditScript(UUID script, UUID objectID, UUID user, Scene scene);
-        private List<CanEditScript> CanEditScriptCheckFunctions = new List<CanEditScript>();
+        public delegate bool CanEditScriptHandler(UUID script, UUID objectID, UUID user, Scene scene);
+        private List<CanEditScriptHandler> CanEditScriptCheckFunctions = new List<CanEditScriptHandler>();
 
-        public void addCheckEditScript(CanEditScript delegateFunc)
+        public void AddEditScriptHandler(CanEditScriptHandler delegateFunc)
         {
             if (!CanEditScriptCheckFunctions.Contains(delegateFunc))
                 CanEditScriptCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckEditScript(CanEditScript delegateFunc)
+        public void RemoveEditScriptHandler(CanEditScriptHandler delegateFunc)
         {
             if (CanEditScriptCheckFunctions.Contains(delegateFunc))
                 CanEditScriptCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanEditScript(UUID script, UUID objectID, UUID user)
+        public bool CanEditScript(UUID script, UUID objectID, UUID user)
         {
-            foreach (CanEditScript check in CanEditScriptCheckFunctions)
+            foreach (CanEditScriptHandler check in CanEditScriptCheckFunctions)
             {
                 if (check(script, objectID, user, m_scene) == false)
                 {
@@ -607,24 +607,24 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }
 
-        public delegate bool CanEditNotecard(UUID notecard, UUID objectID, UUID user, Scene scene);
-        private List<CanEditNotecard> CanEditNotecardCheckFunctions = new List<CanEditNotecard>();
+        public delegate bool CanEditNotecardHandler(UUID notecard, UUID objectID, UUID user, Scene scene);
+        private List<CanEditNotecardHandler> CanEditNotecardCheckFunctions = new List<CanEditNotecardHandler>();
 
-        public void addCheckEditNotecard(CanEditNotecard delegateFunc)
+        public void AddEditNotecardHandler(CanEditNotecardHandler delegateFunc)
         {
             if (!CanEditNotecardCheckFunctions.Contains(delegateFunc))
                 CanEditNotecardCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckEditNotecard(CanEditNotecard delegateFunc)
+        public void RemoveEditNotecardHandler(CanEditNotecardHandler delegateFunc)
         {
             if (CanEditNotecardCheckFunctions.Contains(delegateFunc))
                 CanEditNotecardCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanEditNotecard(UUID script, UUID objectID, UUID user)
+        public bool CanEditNotecard(UUID script, UUID objectID, UUID user)
             {
-                foreach (CanEditNotecard check in CanEditNotecardCheckFunctions)
+                foreach (CanEditNotecardHandler check in CanEditNotecardCheckFunctions)
                 {
                     if (check(script, objectID, user, m_scene) == false)
                     {
@@ -637,24 +637,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region RUN SCRIPT (When Script Placed in Object)
-        public delegate bool CanRunScript(UUID script, UUID objectID, UUID user, Scene scene);
-        private List<CanRunScript> CanRunScriptCheckFunctions = new List<CanRunScript>();
+        public delegate bool CanRunScriptHandler(UUID script, UUID objectID, UUID user, Scene scene);
+        private List<CanRunScriptHandler> CanRunScriptCheckFunctions = new List<CanRunScriptHandler>();
 
-        public void addCheckRunScript(CanRunScript delegateFunc)
+        public void AddRunScriptHandler(CanRunScriptHandler delegateFunc)
         {
             if (!CanRunScriptCheckFunctions.Contains(delegateFunc))
                 CanRunScriptCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckRunScript(CanRunScript delegateFunc)
+        public void RemoveRunScriptHandler(CanRunScriptHandler delegateFunc)
         {
             if (CanRunScriptCheckFunctions.Contains(delegateFunc))
                 CanRunScriptCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanRunScript(UUID script, UUID objectID, UUID user)
+        public bool CanRunScript(UUID script, UUID objectID, UUID user)
         {
-            foreach (CanRunScript check in CanRunScriptCheckFunctions)
+            foreach (CanRunScriptHandler check in CanRunScriptCheckFunctions)
             {
                 if (check(script, objectID, user, m_scene) == false)
                 {
@@ -667,24 +667,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region START SCRIPT (When Script run box is Checked after placed in object)
-        public delegate bool CanStartScript(UUID script, UUID user, Scene scene);
-        private List<CanStartScript> CanStartScriptCheckFunctions = new List<CanStartScript>();
+        public delegate bool CanStartScriptHandler(UUID script, UUID user, Scene scene);
+        private List<CanStartScriptHandler> CanStartScriptCheckFunctions = new List<CanStartScriptHandler>();
 
-        public void addCheckStartScript(CanStartScript delegateFunc)
+        public void AddStartScriptHandler(CanStartScriptHandler delegateFunc)
         {
             if (!CanStartScriptCheckFunctions.Contains(delegateFunc))
                 CanStartScriptCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckStartScript(CanStartScript delegateFunc)
+        public void RemoveStartScriptHandler(CanStartScriptHandler delegateFunc)
         {
             if (CanStartScriptCheckFunctions.Contains(delegateFunc))
                 CanStartScriptCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanStartScript(UUID script, UUID user)
+        public bool CanStartScript(UUID script, UUID user)
         {
-            foreach (CanStartScript check in CanStartScriptCheckFunctions)
+            foreach (CanStartScriptHandler check in CanStartScriptCheckFunctions)
             {
                 if (check(script, user, m_scene) == false)
                 {
@@ -697,24 +697,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region STOP SCRIPT (When Script run box is unchecked after placed in object)
-        public delegate bool CanStopScript(UUID script, UUID user, Scene scene);
-        private List<CanStopScript> CanStopScriptCheckFunctions = new List<CanStopScript>();
+        public delegate bool CanStopScriptHandler(UUID script, UUID user, Scene scene);
+        private List<CanStopScriptHandler> CanStopScriptCheckFunctions = new List<CanStopScriptHandler>();
 
-        public void addCheckStopScript(CanStopScript delegateFunc)
+        public void AddStopScriptHandler(CanStopScriptHandler delegateFunc)
         {
             if (!CanStopScriptCheckFunctions.Contains(delegateFunc))
                 CanStopScriptCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckStopScript(CanStopScript delegateFunc)
+        public void RemoveStopScriptHandler(CanStopScriptHandler delegateFunc)
         {
             if (CanStopScriptCheckFunctions.Contains(delegateFunc))
                 CanStopScriptCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanStopScript(UUID script, UUID user)
+        public bool CanStopScript(UUID script, UUID user)
         {
-            foreach (CanStopScript check in CanStopScriptCheckFunctions)
+            foreach (CanStopScriptHandler check in CanStopScriptCheckFunctions)
             {
                 if (check(script, user, m_scene) == false)
                 {
@@ -727,24 +727,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region RESET SCRIPT
-        public delegate bool CanResetScript(UUID script, UUID user, Scene scene);
-        private List<CanResetScript> CanResetScriptCheckFunctions = new List<CanResetScript>();
+        public delegate bool CanResetScriptHandler(UUID script, UUID user, Scene scene);
+        private List<CanResetScriptHandler> CanResetScriptCheckFunctions = new List<CanResetScriptHandler>();
 
-        public void addCheckResetScript(CanResetScript delegateFunc)
+        public void AddResetScriptHandler(CanResetScriptHandler delegateFunc)
         {
             if (!CanResetScriptCheckFunctions.Contains(delegateFunc))
                 CanResetScriptCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckResetScript(CanResetScript delegateFunc)
+        public void RemoveResetScriptHandler(CanResetScriptHandler delegateFunc)
         {
             if (CanResetScriptCheckFunctions.Contains(delegateFunc))
                 CanResetScriptCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanResetScript(UUID script, UUID user)
+        public bool CanResetScript(UUID script, UUID user)
         {
-            foreach (CanResetScript check in CanResetScriptCheckFunctions)
+            foreach (CanResetScriptHandler check in CanResetScriptCheckFunctions)
             {
                 if (check(script, user, m_scene) == false)
                 {
@@ -757,24 +757,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region TERRAFORM LAND
-        public delegate bool CanTerraformLand(UUID user, Vector3 position, Scene requestFromScene);
-        private List<CanTerraformLand> CanTerraformLandCheckFunctions = new List<CanTerraformLand>();
+        public delegate bool CanTerraformLandHandler(UUID user, Vector3 position, Scene requestFromScene);
+        private List<CanTerraformLandHandler> CanTerraformLandCheckFunctions = new List<CanTerraformLandHandler>();
 
-        public void addCheckTerraformLand(CanTerraformLand delegateFunc)
+        public void AddTerraformLandHandler(CanTerraformLandHandler delegateFunc)
         {
             if (!CanTerraformLandCheckFunctions.Contains(delegateFunc))
                 CanTerraformLandCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckTerraformLand(CanTerraformLand delegateFunc)
+        public void RemoveTerraformLandHandler(CanTerraformLandHandler delegateFunc)
         {
             if (CanTerraformLandCheckFunctions.Contains(delegateFunc))
                 CanTerraformLandCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanTerraformLand(UUID user, Vector3 pos)
+        public bool CanTerraformLand(UUID user, Vector3 pos)
         {
-            foreach (CanTerraformLand check in CanTerraformLandCheckFunctions)
+            foreach (CanTerraformLandHandler check in CanTerraformLandCheckFunctions)
             {
                 if (check(user, pos, m_scene) == false)
                 {
@@ -787,24 +787,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region RUN CONSOLE COMMAND
-        public delegate bool CanRunConsoleCommand(UUID user, Scene requestFromScene);
-        private List<CanRunConsoleCommand> CanRunConsoleCommandCheckFunctions = new List<CanRunConsoleCommand>();
+        public delegate bool CanRunConsoleCommandHandler(UUID user, Scene requestFromScene);
+        private List<CanRunConsoleCommandHandler> CanRunConsoleCommandCheckFunctions = new List<CanRunConsoleCommandHandler>();
 
-        public void addCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)
+        public void AddRunConsoleCommandHandler(CanRunConsoleCommandHandler delegateFunc)
         {
             if (!CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))
                 CanRunConsoleCommandCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)
+        public void RemoveRunConsoleCommandHandler(CanRunConsoleCommandHandler delegateFunc)
         {
             if (CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))
                 CanRunConsoleCommandCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanRunConsoleCommand(UUID user)
+        public bool CanRunConsoleCommand(UUID user)
         {
-            foreach (CanRunConsoleCommand check in CanRunConsoleCommandCheckFunctions)
+            foreach (CanRunConsoleCommandHandler check in CanRunConsoleCommandCheckFunctions)
             {
                 if (check(user, m_scene) == false)
                 {
@@ -817,24 +817,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region CAN ISSUE ESTATE COMMAND
-        public delegate bool CanIssueEstateCommand(UUID user, Scene requestFromScene, bool ownerCommand);
-        private List<CanIssueEstateCommand> CanIssueEstateCommandCheckFunctions = new List<CanIssueEstateCommand>();
+        public delegate bool CanIssueEstateCommandHandler(UUID user, Scene requestFromScene, bool ownerCommand);
+        private List<CanIssueEstateCommandHandler> CanIssueEstateCommandCheckFunctions = new List<CanIssueEstateCommandHandler>();
 
-        public void addCheckIssueEstateCommand(CanIssueEstateCommand delegateFunc)
+        public void AddIssueEstateCommandHandler(CanIssueEstateCommandHandler delegateFunc)
         {
             if (!CanIssueEstateCommandCheckFunctions.Contains(delegateFunc))
                 CanIssueEstateCommandCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckIssueEstateCommand(CanIssueEstateCommand delegateFunc)
+        public void RemoveIssueEstateCommandHandler(CanIssueEstateCommandHandler delegateFunc)
         {
             if (CanIssueEstateCommandCheckFunctions.Contains(delegateFunc))
                 CanIssueEstateCommandCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanIssueEstateCommand(UUID user, bool ownerCommand)
+        public bool CanIssueEstateCommand(UUID user, bool ownerCommand)
         {
-            foreach (CanIssueEstateCommand check in CanIssueEstateCommandCheckFunctions)
+            foreach (CanIssueEstateCommandHandler check in CanIssueEstateCommandCheckFunctions)
             {
                 if (check(user, m_scene, ownerCommand) == false)
                 {
@@ -846,24 +846,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region CAN BE GODLIKE
-        public delegate bool CanBeGodLike(UUID user, Scene requestFromScene);
-        private List<CanBeGodLike> CanBeGodLikeCheckFunctions = new List<CanBeGodLike>();
+        public delegate bool IsGodHandler(UUID user, Scene requestFromScene);
+        private List<IsGodHandler> IsGodCheckFunctions = new List<IsGodHandler>();
 
-        public void addCheckBeGodLike(CanBeGodLike delegateFunc)
+        public void AddIsGodHandler(IsGodHandler delegateFunc)
         {
-            if (!CanBeGodLikeCheckFunctions.Contains(delegateFunc))
-                CanBeGodLikeCheckFunctions.Add(delegateFunc);
+            if (!IsGodCheckFunctions.Contains(delegateFunc))
+                IsGodCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckBeGodLike(CanBeGodLike delegateFunc)
+        public void RemoveIsGodHandler(IsGodHandler delegateFunc)
         {
-            if (CanBeGodLikeCheckFunctions.Contains(delegateFunc))
-                CanBeGodLikeCheckFunctions.Remove(delegateFunc);
+            if (IsGodCheckFunctions.Contains(delegateFunc))
+                IsGodCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanBeGodLike(UUID user)
+        public bool IsGod(UUID user)
         {
-            foreach (CanBeGodLike check in CanBeGodLikeCheckFunctions)
+            foreach (IsGodHandler check in IsGodCheckFunctions)
             {
                 if (check(user, m_scene) == false)
                 {
@@ -875,24 +875,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region EDIT PARCEL
-        public delegate bool CanEditParcel(UUID user, ILandObject parcel, Scene scene);
-        private List<CanEditParcel> CanEditParcelCheckFunctions = new List<CanEditParcel>();
+        public delegate bool CanEditParcelHandler(UUID user, ILandObject parcel, Scene scene);
+        private List<CanEditParcelHandler> CanEditParcelCheckFunctions = new List<CanEditParcelHandler>();
 
-        public void addCheckEditParcel(CanEditParcel delegateFunc)
+        public void AddEditParcelHandler(CanEditParcelHandler delegateFunc)
         {
             if (!CanEditParcelCheckFunctions.Contains(delegateFunc))
                 CanEditParcelCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckEditParcel(CanEditParcel delegateFunc)
+        public void RemoveEditParcelHandler(CanEditParcelHandler delegateFunc)
         {
             if (CanEditParcelCheckFunctions.Contains(delegateFunc))
                 CanEditParcelCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanEditParcel(UUID user, ILandObject parcel)
+        public bool CanEditParcel(UUID user, ILandObject parcel)
         {
-            foreach (CanEditParcel check in CanEditParcelCheckFunctions)
+            foreach (CanEditParcelHandler check in CanEditParcelCheckFunctions)
             {
                 if (check(user, parcel, m_scene) == false)
                 {
@@ -904,24 +904,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region SELL PARCEL
-        public delegate bool CanSellParcel(UUID user, ILandObject parcel, Scene scene);
-        private List<CanSellParcel> CanSellParcelCheckFunctions = new List<CanSellParcel>();
+        public delegate bool CanSellParcelHandler(UUID user, ILandObject parcel, Scene scene);
+        private List<CanSellParcelHandler> CanSellParcelCheckFunctions = new List<CanSellParcelHandler>();
 
-        public void addCheckSellParcel(CanSellParcel delegateFunc)
+        public void AddSellParcelHandler(CanSellParcelHandler delegateFunc)
         {
             if (!CanSellParcelCheckFunctions.Contains(delegateFunc))
                 CanSellParcelCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckSellParcel(CanSellParcel delegateFunc)
+        public void RemoveSellParcelHandler(CanSellParcelHandler delegateFunc)
         {
             if (CanSellParcelCheckFunctions.Contains(delegateFunc))
                 CanSellParcelCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanSellParcel(UUID user, ILandObject parcel)
+        public bool CanSellParcel(UUID user, ILandObject parcel)
         {
-            foreach (CanSellParcel check in CanSellParcelCheckFunctions)
+            foreach (CanSellParcelHandler check in CanSellParcelCheckFunctions)
             {
                 if (check(user, parcel, m_scene) == false)
                 {
@@ -933,24 +933,24 @@ namespace OpenSim.Region.Environment.Scenes
         #endregion
 
         #region ABANDON PARCEL
-        public delegate bool CanAbandonParcel(UUID user, ILandObject parcel, Scene scene);
-        private List<CanAbandonParcel> CanAbandonParcelCheckFunctions = new List<CanAbandonParcel>();
+        public delegate bool CanAbandonParcelHandler(UUID user, ILandObject parcel, Scene scene);
+        private List<CanAbandonParcelHandler> CanAbandonParcelCheckFunctions = new List<CanAbandonParcelHandler>();
 
-        public void addCheckAbandonParcel(CanAbandonParcel delegateFunc)
+        public void AddAbandonParcelHandler(CanAbandonParcelHandler delegateFunc)
         {
             if (!CanAbandonParcelCheckFunctions.Contains(delegateFunc))
                 CanAbandonParcelCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckAbandonParcel(CanAbandonParcel delegateFunc)
+        public void RemoveAbandonParcelHandler(CanAbandonParcelHandler delegateFunc)
         {
             if (CanAbandonParcelCheckFunctions.Contains(delegateFunc))
                 CanAbandonParcelCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanAbandonParcel(UUID user, ILandObject parcel)
+        public bool CanAbandonParcel(UUID user, ILandObject parcel)
         {
-            foreach (CanAbandonParcel check in CanAbandonParcelCheckFunctions)
+            foreach (CanAbandonParcelHandler check in CanAbandonParcelCheckFunctions)
             {
                 if (check(user, parcel, m_scene) == false)
                 {
@@ -961,24 +961,24 @@ namespace OpenSim.Region.Environment.Scenes
         }
         #endregion
 
-        public delegate bool CanReclaimParcel(UUID user, ILandObject parcel, Scene scene);
-        private List<CanReclaimParcel> CanReclaimParcelCheckFunctions = new List<CanReclaimParcel>();
+        public delegate bool CanReclaimParcelHandler(UUID user, ILandObject parcel, Scene scene);
+        private List<CanReclaimParcelHandler> CanReclaimParcelCheckFunctions = new List<CanReclaimParcelHandler>();
 
-        public void addCheckReclaimParcel(CanReclaimParcel delegateFunc)
+        public void AddReclaimParcelHandler(CanReclaimParcelHandler delegateFunc)
         {
             if (!CanReclaimParcelCheckFunctions.Contains(delegateFunc))
                 CanReclaimParcelCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckReclaimParcel(CanReclaimParcel delegateFunc)
+        public void RemoveReclaimParcelHandler(CanReclaimParcelHandler delegateFunc)
         {
             if (CanReclaimParcelCheckFunctions.Contains(delegateFunc))
                 CanReclaimParcelCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanReclaimParcel(UUID user, ILandObject parcel)
+        public bool CanReclaimParcel(UUID user, ILandObject parcel)
         {
-            foreach (CanReclaimParcel check in CanReclaimParcelCheckFunctions)
+            foreach (CanReclaimParcelHandler check in CanReclaimParcelCheckFunctions)
             {
                 if (check(user, parcel, m_scene) == false)
                 {
@@ -987,24 +987,24 @@ namespace OpenSim.Region.Environment.Scenes
             }
             return true;
         }
-        public delegate bool CanBuyLand(UUID user, ILandObject parcel, Scene scene);
-        private List<CanBuyLand> CanBuyLandCheckFunctions = new List<CanBuyLand>();
+        public delegate bool CanBuyLandHandler(UUID user, ILandObject parcel, Scene scene);
+        private List<CanBuyLandHandler> CanBuyLandCheckFunctions = new List<CanBuyLandHandler>();
 
-        public void addCheckCanBuyLand(CanBuyLand delegateFunc)
+        public void AddCanBuyLandHandler(CanBuyLandHandler delegateFunc)
         {
             if (!CanBuyLandCheckFunctions.Contains(delegateFunc))
                 CanBuyLandCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanBuyLand(CanBuyLand delegateFunc)
+        public void RemoveCanBuyLandHandler(CanBuyLandHandler delegateFunc)
         {
             if (CanBuyLandCheckFunctions.Contains(delegateFunc))
                 CanBuyLandCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanBuyLand(UUID user, ILandObject parcel)
+        public bool CanBuyLand(UUID user, ILandObject parcel)
         {
-            foreach (CanBuyLand check in CanBuyLandCheckFunctions)
+            foreach (CanBuyLandHandler check in CanBuyLandCheckFunctions)
             {
                 if (check(user, parcel, m_scene) == false)
                 {
@@ -1014,24 +1014,24 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }
 
-        public delegate bool CanLinkObject(UUID user, UUID objectID);
-        private List<CanLinkObject> CanLinkObjectCheckFunctions = new List<CanLinkObject>();
+        public delegate bool CanLinkObjectHandler(UUID user, UUID objectID);
+        private List<CanLinkObjectHandler> CanLinkObjectCheckFunctions = new List<CanLinkObjectHandler>();
 
-        public void addCheckCanLinkObject(CanLinkObject delegateFunc)
+        public void AddCanLinkObjectHandler(CanLinkObjectHandler delegateFunc)
         {
             if (!CanLinkObjectCheckFunctions.Contains(delegateFunc))
                 CanLinkObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanLinkObject(CanLinkObject delegateFunc)
+        public void RemoveCanLinkObjectHandler(CanLinkObjectHandler delegateFunc)
         {
             if (CanLinkObjectCheckFunctions.Contains(delegateFunc))
                 CanLinkObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanLinkObject(UUID user, UUID objectID)
+        public bool CanLinkObject(UUID user, UUID objectID)
             {
-                foreach (CanLinkObject check in CanLinkObjectCheckFunctions)
+                foreach (CanLinkObjectHandler check in CanLinkObjectCheckFunctions)
                 {
                     if (check(user, objectID) == false)
                     {
@@ -1041,24 +1041,24 @@ namespace OpenSim.Region.Environment.Scenes
                 return true;
             }
 
-        public delegate bool CanDelinkObject(UUID user, UUID objectID);
-        private List<CanDelinkObject> CanDelinkObjectCheckFunctions = new List<CanDelinkObject>();
+        public delegate bool CanDelinkObjectHandler(UUID user, UUID objectID);
+        private List<CanDelinkObjectHandler> CanDelinkObjectCheckFunctions = new List<CanDelinkObjectHandler>();
 
-        public void addCheckCanDelinkObject(CanDelinkObject delegateFunc)
+        public void AddCanDelinkObjectHandler(CanDelinkObjectHandler delegateFunc)
         {
             if (!CanDelinkObjectCheckFunctions.Contains(delegateFunc))
                 CanDelinkObjectCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanDelinkObject(CanDelinkObject delegateFunc)
+        public void RemoveCanDelinkObjectHandler(CanDelinkObjectHandler delegateFunc)
         {
             if (CanDelinkObjectCheckFunctions.Contains(delegateFunc))
                 CanDelinkObjectCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanDelinkObject(UUID user, UUID objectID)
+        public bool CanDelinkObject(UUID user, UUID objectID)
         {
-            foreach (CanDelinkObject check in CanDelinkObjectCheckFunctions)
+            foreach (CanDelinkObjectHandler check in CanDelinkObjectCheckFunctions)
             {
                 if (check(user, objectID) == false)
                 {
@@ -1070,18 +1070,18 @@ namespace OpenSim.Region.Environment.Scenes
 
         #endregion
 
-        public delegate bool CanCreateObjectInventory(int invType, UUID objectID, UUID userID);
-        private List<CanCreateObjectInventory> CanCreateObjectInventoryCheckFunctions 
-            = new List<CanCreateObjectInventory>();
+        public delegate bool CanCreateObjectInventoryHandler(int invType, UUID objectID, UUID userID);
+        private List<CanCreateObjectInventoryHandler> CanCreateObjectInventoryCheckFunctions 
+            = new List<CanCreateObjectInventoryHandler>();
 
         
-        public void addCheckCanCreateObjectInventory(CanCreateObjectInventory delegateFunc)
+        public void AddCanCreateObjectInventoryHandler(CanCreateObjectInventoryHandler delegateFunc)
         {
             if (!CanCreateObjectInventoryCheckFunctions.Contains(delegateFunc))
                 CanCreateObjectInventoryCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanCreateObjectInventory(CanCreateObjectInventory delegateFunc)
+        public void RemoveCanCreateObjectInventoryHandler(CanCreateObjectInventoryHandler delegateFunc)
         {
             if (CanCreateObjectInventoryCheckFunctions.Contains(delegateFunc))
                 CanCreateObjectInventoryCheckFunctions.Remove(delegateFunc);
@@ -1095,9 +1095,9 @@ namespace OpenSim.Region.Environment.Scenes
         /// <param name="objectID"></param>
         /// <param name="userID"></param>
         /// <returns></returns>         
-        public bool ExternalChecksCanCreateObjectInventory(int invType, UUID objectID, UUID userID)
+        public bool CanCreateObjectInventory(int invType, UUID objectID, UUID userID)
         {
-            foreach (CanCreateObjectInventory check in CanCreateObjectInventoryCheckFunctions)
+            foreach (CanCreateObjectInventoryHandler check in CanCreateObjectInventoryCheckFunctions)
             {
                 if (check(invType, objectID, userID) == false)
                 {
@@ -1108,24 +1108,24 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }
 
-        public delegate bool CanCopyObjectInventory(UUID itemID, UUID objectID, UUID userID);
-        private List<CanCopyObjectInventory> CanCopyObjectInventoryCheckFunctions = new List<CanCopyObjectInventory>();
+        public delegate bool CanCopyObjectInventoryHandler(UUID itemID, UUID objectID, UUID userID);
+        private List<CanCopyObjectInventoryHandler> CanCopyObjectInventoryCheckFunctions = new List<CanCopyObjectInventoryHandler>();
 
-        public void addCheckCanCopyObjectInventory(CanCopyObjectInventory delegateFunc)
+        public void AddCanCopyObjectInventoryHandler(CanCopyObjectInventoryHandler delegateFunc)
         {
             if (!CanCopyObjectInventoryCheckFunctions.Contains(delegateFunc))
                 CanCopyObjectInventoryCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanCopyObjectInventory(CanCopyObjectInventory delegateFunc)
+        public void RemoveCanCopyObjectInventoryHandler(CanCopyObjectInventoryHandler delegateFunc)
         {
             if (CanCopyObjectInventoryCheckFunctions.Contains(delegateFunc))
                 CanCopyObjectInventoryCheckFunctions.Remove(delegateFunc);
         }
        
-        public bool ExternalChecksCanCopyObjectInventory(UUID itemID, UUID objectID, UUID userID)
+        public bool CanCopyObjectInventory(UUID itemID, UUID objectID, UUID userID)
         {
-            foreach (CanCopyObjectInventory check in CanCopyObjectInventoryCheckFunctions)
+            foreach (CanCopyObjectInventoryHandler check in CanCopyObjectInventoryCheckFunctions)
             {
                 if (check(itemID, objectID, userID) == false)
                 {
@@ -1135,25 +1135,25 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }
 
-        public delegate bool CanDeleteObjectInventory(UUID itemID, UUID objectID, UUID userID);
-        private List<CanDeleteObjectInventory> CanDeleteObjectInventoryCheckFunctions 
-            = new List<CanDeleteObjectInventory>();
+        public delegate bool CanDeleteObjectInventoryHandler(UUID itemID, UUID objectID, UUID userID);
+        private List<CanDeleteObjectInventoryHandler> CanDeleteObjectInventoryCheckFunctions 
+            = new List<CanDeleteObjectInventoryHandler>();
 
-        public void addCheckCanDeleteObjectInventory(CanDeleteObjectInventory delegateFunc)
+        public void AddCanDeleteObjectInventoryHandler(CanDeleteObjectInventoryHandler delegateFunc)
         {
             if (!CanDeleteObjectInventoryCheckFunctions.Contains(delegateFunc))
                 CanDeleteObjectInventoryCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanDeleteObjectInventory(CanDeleteObjectInventory delegateFunc)
+        public void RemoveCanDeleteObjectInventoryHandler(CanDeleteObjectInventoryHandler delegateFunc)
         {
             if (CanDeleteObjectInventoryCheckFunctions.Contains(delegateFunc))
                 CanDeleteObjectInventoryCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanDeleteObjectInventory(UUID itemID, UUID objectID, UUID userID)
+        public bool CanDeleteObjectInventory(UUID itemID, UUID objectID, UUID userID)
         {
-            foreach (CanDeleteObjectInventory check in CanDeleteObjectInventoryCheckFunctions)
+            foreach (CanDeleteObjectInventoryHandler check in CanDeleteObjectInventoryCheckFunctions)
             {
                 if (check(itemID, objectID, userID) == false)
                 {
@@ -1164,17 +1164,17 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }
         
-        public delegate bool CanCreateUserInventory(int invType, UUID userID);
-        private List<CanCreateUserInventory> CanCreateUserInventoryCheckFunctions 
-            = new List<CanCreateUserInventory>();
+        public delegate bool CanCreateUserInventoryHandler(int invType, UUID userID);
+        private List<CanCreateUserInventoryHandler> CanCreateUserInventoryCheckFunctions 
+            = new List<CanCreateUserInventoryHandler>();
         
-        public void addCheckCanCreateUserInventory(CanCreateUserInventory delegateFunc)
+        public void AddCanCreateUserInventoryHandler(CanCreateUserInventoryHandler delegateFunc)
         {
             if (!CanCreateUserInventoryCheckFunctions.Contains(delegateFunc))
                 CanCreateUserInventoryCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanCreateUserInventory(CanCreateUserInventory delegateFunc)
+        public void RemoveCanCreateUserInventoryHandler(CanCreateUserInventoryHandler delegateFunc)
         {
             if (CanCreateUserInventoryCheckFunctions.Contains(delegateFunc))
                 CanCreateUserInventoryCheckFunctions.Remove(delegateFunc);
@@ -1186,9 +1186,9 @@ namespace OpenSim.Region.Environment.Scenes
         /// <param name="invType"></param>
         /// <param name="userID"></param>
         /// <returns></returns>         
-        public bool ExternalChecksCanCreateUserInventory(int invType, UUID userID)
+        public bool CanCreateUserInventory(int invType, UUID userID)
         {
-            foreach (CanCreateUserInventory check in CanCreateUserInventoryCheckFunctions)
+            foreach (CanCreateUserInventoryHandler check in CanCreateUserInventoryCheckFunctions)
             {
                 if (check(invType, userID) == false)
                 {
@@ -1199,17 +1199,17 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         } 
         
-        public delegate bool CanEditUserInventory(UUID itemID, UUID userID);
-        private List<CanEditUserInventory> CanEditUserInventoryCheckFunctions 
-            = new List<CanEditUserInventory>();
+        public delegate bool CanEditUserInventoryHandler(UUID itemID, UUID userID);
+        private List<CanEditUserInventoryHandler> CanEditUserInventoryCheckFunctions 
+            = new List<CanEditUserInventoryHandler>();
         
-        public void addCheckCanEditUserInventory(CanEditUserInventory delegateFunc)
+        public void AddCanEditUserInventoryHandler(CanEditUserInventoryHandler delegateFunc)
         {
             if (!CanEditUserInventoryCheckFunctions.Contains(delegateFunc))
                 CanEditUserInventoryCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanEditUserInventory(CanEditUserInventory delegateFunc)
+        public void RemoveCanEditUserInventoryHandler(CanEditUserInventoryHandler delegateFunc)
         {
             if (CanEditUserInventoryCheckFunctions.Contains(delegateFunc))
                 CanEditUserInventoryCheckFunctions.Remove(delegateFunc);
@@ -1221,9 +1221,9 @@ namespace OpenSim.Region.Environment.Scenes
         /// <param name="itemID"></param>
         /// <param name="userID"></param>
         /// <returns></returns>         
-        public bool ExternalChecksCanEditUserInventory(UUID itemID, UUID userID)
+        public bool CanEditUserInventory(UUID itemID, UUID userID)
         {
-            foreach (CanEditUserInventory check in CanEditUserInventoryCheckFunctions)
+            foreach (CanEditUserInventoryHandler check in CanEditUserInventoryCheckFunctions)
             {
                 if (check(itemID, userID) == false)
                 {
@@ -1234,17 +1234,17 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }         
         
-        public delegate bool CanCopyUserInventory(UUID itemID, UUID userID);
-        private List<CanCopyUserInventory> CanCopyUserInventoryCheckFunctions 
-            = new List<CanCopyUserInventory>();
+        public delegate bool CanCopyUserInventoryHandler(UUID itemID, UUID userID);
+        private List<CanCopyUserInventoryHandler> CanCopyUserInventoryCheckFunctions 
+            = new List<CanCopyUserInventoryHandler>();
         
-        public void addCheckCanCopyUserInventory(CanCopyUserInventory delegateFunc)
+        public void AddCanCopyUserInventoryHandler(CanCopyUserInventoryHandler delegateFunc)
         {
             if (!CanCopyUserInventoryCheckFunctions.Contains(delegateFunc))
                 CanCopyUserInventoryCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanCopyUserInventory(CanCopyUserInventory delegateFunc)
+        public void RemoveCanCopyUserInventoryHandler(CanCopyUserInventoryHandler delegateFunc)
         {
             if (CanCopyUserInventoryCheckFunctions.Contains(delegateFunc))
                 CanCopyUserInventoryCheckFunctions.Remove(delegateFunc);
@@ -1256,9 +1256,9 @@ namespace OpenSim.Region.Environment.Scenes
         /// <param name="itemID"></param>
         /// <param name="userID"></param>
         /// <returns></returns>         
-        public bool ExternalChecksCanCopyUserInventory(UUID itemID, UUID userID)
+        public bool CanCopyUserInventory(UUID itemID, UUID userID)
         {
-            foreach (CanCopyUserInventory check in CanCopyUserInventoryCheckFunctions)
+            foreach (CanCopyUserInventoryHandler check in CanCopyUserInventoryCheckFunctions)
             {
                 if (check(itemID, userID) == false)
                 {
@@ -1269,17 +1269,17 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }         
         
-        public delegate bool CanDeleteUserInventory(UUID itemID, UUID userID);
-        private List<CanDeleteUserInventory> CanDeleteUserInventoryCheckFunctions 
-            = new List<CanDeleteUserInventory>();
+        public delegate bool CanDeleteUserInventoryHandler(UUID itemID, UUID userID);
+        private List<CanDeleteUserInventoryHandler> CanDeleteUserInventoryCheckFunctions 
+            = new List<CanDeleteUserInventoryHandler>();
         
-        public void addCheckCanDeleteUserInventory(CanDeleteUserInventory delegateFunc)
+        public void AddCanDeleteUserInventoryHandler(CanDeleteUserInventoryHandler delegateFunc)
         {
             if (!CanDeleteUserInventoryCheckFunctions.Contains(delegateFunc))
                 CanDeleteUserInventoryCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanDeleteUserInventory(CanDeleteUserInventory delegateFunc)
+        public void RemoveCanDeleteUserInventoryHandler(CanDeleteUserInventoryHandler delegateFunc)
         {
             if (CanDeleteUserInventoryCheckFunctions.Contains(delegateFunc))
                 CanDeleteUserInventoryCheckFunctions.Remove(delegateFunc);
@@ -1291,9 +1291,9 @@ namespace OpenSim.Region.Environment.Scenes
         /// <param name="itemID"></param>
         /// <param name="userID"></param>
         /// <returns></returns>         
-        public bool ExternalChecksCanDeleteUserInventory(UUID itemID, UUID userID)
+        public bool CanDeleteUserInventory(UUID itemID, UUID userID)
         {
-            foreach (CanDeleteUserInventory check in CanDeleteUserInventoryCheckFunctions)
+            foreach (CanDeleteUserInventoryHandler check in CanDeleteUserInventoryCheckFunctions)
             {
                 if (check(itemID, userID) == false)
                 {
@@ -1304,24 +1304,24 @@ namespace OpenSim.Region.Environment.Scenes
             return true;
         }         
         
-        public delegate bool CanTeleport(UUID userID);
-        private List<CanTeleport> CanTeleportCheckFunctions = new List<CanTeleport>();
+        public delegate bool CanTeleportHandler(UUID userID);
+        private List<CanTeleportHandler> CanTeleportCheckFunctions = new List<CanTeleportHandler>();
 
-        public void addCheckCanTeleport(CanTeleport delegateFunc)
+        public void AddCanTeleportHandler(CanTeleportHandler delegateFunc)
         {
             if (!CanTeleportCheckFunctions.Contains(delegateFunc))
                 CanTeleportCheckFunctions.Add(delegateFunc);
         }
 
-        public void removeCheckCanTeleport(CanTeleport delegateFunc)
+        public void RemoveCanTeleportHandler(CanTeleportHandler delegateFunc)
         {
             if (CanTeleportCheckFunctions.Contains(delegateFunc))
                 CanTeleportCheckFunctions.Remove(delegateFunc);
         }
 
-        public bool ExternalChecksCanTeleport(UUID userID)
+        public bool CanTeleport(UUID userID)
         {
-            foreach (CanTeleport check in CanTeleportCheckFunctions)
+            foreach (CanTeleportHandler check in CanTeleportCheckFunctions)
             {
                 if (check(userID) == false)
                 {
diff --git a/OpenSim/Region/Environment/Scenes/Scene.cs b/OpenSim/Region/Environment/Scenes/Scene.cs
index 9c29c44..723f874 100644
--- a/OpenSim/Region/Environment/Scenes/Scene.cs
+++ b/OpenSim/Region/Environment/Scenes/Scene.cs
@@ -293,7 +293,7 @@ namespace OpenSim.Region.Environment.Scenes
             m_seeIntoRegionFromNeighbor = SeeIntoRegionFromNeighbor;
 
             m_eventManager = new EventManager();
-            m_externalChecks = new SceneExternalChecks(this);
+            m_permissions = new ScenePermissions(this);
             
             m_asyncSceneObjectDeleter = new AsyncSceneObjectGroupDeleter(this);
             m_asyncSceneObjectDeleter.Enabled = true;
@@ -1750,7 +1750,7 @@ namespace OpenSim.Region.Environment.Scenes
         {
             Vector3 pos = GetNewRezLocation(RayStart, RayEnd, RayTargetID, rot, bypassRaycast, RayEndIsIntersection, true, new Vector3(0.5f, 0.5f, 0.5f), false);
 
-            if (ExternalChecks.ExternalChecksCanRezObject(1, ownerID, pos))
+            if (Permissions.CanRezObject(1, ownerID, pos))
             {
                 // rez ON the ground, not IN the ground
                 pos.Z += 0.25F;
@@ -3450,7 +3450,7 @@ namespace OpenSim.Region.Environment.Scenes
                     }
 
                     // First check that this is the sim owner
-                    if (ExternalChecks.ExternalChecksCanBeGodLike(agentID))
+                    if (Permissions.IsGod(agentID))
                     {
                         // Next we check for spoofing.....
                         UUID testSessionID = m_scenePresences[agentID].ControllingClient.SessionId;
@@ -3527,7 +3527,7 @@ namespace OpenSim.Region.Environment.Scenes
             {
                 if (m_scenePresences.ContainsKey(agentID) || agentID == kickUserID)
                 {
-                    if (ExternalChecks.ExternalChecksCanBeGodLike(godID))
+                    if (Permissions.IsGod(godID))
                     {
                         if (agentID == kickUserID)
                         {
@@ -3848,7 +3848,7 @@ namespace OpenSim.Region.Environment.Scenes
                     }
                     else if ((parcel.landData.Flags & (uint)Parcel.ParcelFlags.AllowGroupScripts) != 0)
                     {
-                        if (part.OwnerID == parcel.landData.OwnerID || (parcel.landData.IsGroupOwned && part.GroupID == parcel.landData.GroupID) || ExternalChecks.ExternalChecksCanBeGodLike(part.OwnerID))
+                        if (part.OwnerID == parcel.landData.OwnerID || (parcel.landData.IsGroupOwned && part.GroupID == parcel.landData.GroupID) || Permissions.IsGod(part.OwnerID))
                         {
                             return true;
                         }
@@ -4273,7 +4273,7 @@ namespace OpenSim.Region.Environment.Scenes
                 List<SceneObjectPart> partList =
                     new List<SceneObjectPart>(group.Children.Values);
 
-                if (ExternalChecks.ExternalChecksPropagatePermissions())
+                if (Permissions.PropagatePermissions())
                 {
                     foreach (SceneObjectPart child in partList)
                     {
diff --git a/OpenSim/Region/Environment/Scenes/SceneBase.cs b/OpenSim/Region/Environment/Scenes/SceneBase.cs
index ee0f6b1..7137c2f 100644
--- a/OpenSim/Region/Environment/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneBase.cs
@@ -84,10 +84,10 @@ namespace OpenSim.Region.Environment.Scenes
         }
 
 
-        protected SceneExternalChecks m_externalChecks;
-        public SceneExternalChecks ExternalChecks
+        protected ScenePermissions m_permissions;
+        public ScenePermissions Permissions
         {
-            get { return m_externalChecks; }
+            get { return m_permissions; }
         }
 
         protected string m_datastore;
diff --git a/OpenSim/Region/Environment/Scenes/SceneCommunicationService.cs b/OpenSim/Region/Environment/Scenes/SceneCommunicationService.cs
index 8167c68..64da9d4 100644
--- a/OpenSim/Region/Environment/Scenes/SceneCommunicationService.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneCommunicationService.cs
@@ -599,7 +599,7 @@ namespace OpenSim.Region.Environment.Scenes
         public virtual void RequestTeleportToLocation(ScenePresence avatar, ulong regionHandle, Vector3 position,
                                                       Vector3 lookAt, uint teleportFlags)
         {
-            if (!avatar.Scene.ExternalChecks.ExternalChecksCanTeleport(avatar.UUID))
+            if (!avatar.Scene.Permissions.CanTeleport(avatar.UUID))
                 return;
 
             bool destRegionUp = false;
diff --git a/OpenSim/Region/Environment/Scenes/SceneGraph.cs b/OpenSim/Region/Environment/Scenes/SceneGraph.cs
index 18fe151..4c15da2 100644
--- a/OpenSim/Region/Environment/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneGraph.cs
@@ -431,7 +431,7 @@ namespace OpenSim.Region.Environment.Scenes
                     {
                         SceneObjectGroup group = (SceneObjectGroup)obj;
 
-                        if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
+                        if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                             group.SetGroup(GroupID, remoteClient);
                         else
                             remoteClient.SendAgentAlertMessage("You don't have permission to set the group", false);
@@ -455,7 +455,7 @@ namespace OpenSim.Region.Environment.Scenes
             if (part == null)
                 return;
 
-            if (!m_parentScene.ExternalChecks.ExternalChecksCanTakeObject(
+            if (!m_parentScene.Permissions.CanTakeObject(
                     part.UUID, remoteClient.AgentId))
                 return;
 
@@ -522,7 +522,7 @@ namespace OpenSim.Region.Environment.Scenes
                     if (((SceneObjectGroup)obj).LocalId == objectLocalID)
                     {
                         SceneObjectGroup group = (SceneObjectGroup)obj;
-                        if (m_parentScene.ExternalChecks.ExternalChecksCanTakeObject(obj.UUID, remoteClient.AgentId))
+                        if (m_parentScene.Permissions.CanTakeObject(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
@@ -1056,7 +1056,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.Resize(scale, localID);
                 }
@@ -1068,7 +1068,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.GroupResize(scale, localID);
                 }
@@ -1104,7 +1104,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId))
                 {
                     group.UpdateSingleRotation(rot, localID);
                 }
@@ -1122,7 +1122,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId))
                 {
                     group.UpdateGroupRotation(rot);
                 }
@@ -1141,7 +1141,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId))
                 {
                     group.UpdateGroupRotation(pos, rot);
                 }
@@ -1159,7 +1159,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId) || group.IsAttachment)
+                if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId) || group.IsAttachment)
                 {
                     group.UpdateSinglePosition(pos, localID);
                 }
@@ -1185,7 +1185,7 @@ namespace OpenSim.Region.Environment.Scenes
                 }
                 else
                 {
-                    if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId) || group.IsAttachment)
+                    if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId) || group.IsAttachment)
                     {
                         group.UpdateGroupPosition(pos);
                     }
@@ -1204,7 +1204,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID,remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanEditObject(group.UUID,remoteClient.AgentId))
                 {
                     group.UpdateTextureEntry(localID, texture);
                 }
@@ -1222,7 +1222,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(localID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.UpdatePrimFlags(localID, UsePhysics, IsTemporary, IsPhantom);
                 }
@@ -1241,7 +1241,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(objectID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(group.UUID, remoteClient.AgentId))// && PermissionsMngr.)
+                if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId))// && PermissionsMngr.)
                 {
                     group.GrabMovement(offset, pos, remoteClient);
                 }
@@ -1263,7 +1263,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(primLocalID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.SetPartName(Util.CleanString(name), primLocalID);
                     group.HasGroupChanged = true;
@@ -1281,7 +1281,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(primLocalID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     group.SetPartDescription(Util.CleanString(description), primLocalID);
                     group.HasGroupChanged = true;
@@ -1294,7 +1294,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(primLocalID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     SceneObjectPart part = m_parentScene.GetSceneObjectPart(primLocalID);
                     part.ClickAction = Convert.ToByte(clickAction);
@@ -1308,7 +1308,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(primLocalID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID, remoteClient.AgentId))
+                if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId))
                 {
                     SceneObjectPart part = m_parentScene.GetSceneObjectPart(primLocalID);
                     part.Material = Convert.ToByte(material);
@@ -1323,7 +1323,7 @@ namespace OpenSim.Region.Environment.Scenes
 
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.UUID,agentID))
+                if (m_parentScene.Permissions.CanEditObject(group.UUID,agentID))
                 {
                     group.UpdateExtraParam(primLocalID, type, inUse, data);
                 }
@@ -1340,7 +1340,7 @@ namespace OpenSim.Region.Environment.Scenes
             SceneObjectGroup group = GetGroupByPrim(primLocalID);
             if (group != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanEditObject(group.GetPartsFullID(primLocalID), agentID))
+                if (m_parentScene.Permissions.CanEditObject(group.GetPartsFullID(primLocalID), agentID))
                 {
                     ObjectShapePacket.ObjectDataBlock shapeData = new ObjectShapePacket.ObjectDataBlock();
                     shapeData.ObjectLocalID = shapeBlock.ObjectLocalID;
@@ -1612,12 +1612,12 @@ namespace OpenSim.Region.Environment.Scenes
             // libomv will complain about PrimFlags.JointWheel being
             // deprecated, so we
             #pragma warning disable 0612
-            if (IncludeInSearch && m_parentScene.ExternalChecks.ExternalChecksCanEditObject(objid, user))
+            if (IncludeInSearch && m_parentScene.Permissions.CanEditObject(objid, user))
             {
                 obj.ParentGroup.RootPart.AddFlag(PrimFlags.JointWheel);
                 obj.ParentGroup.HasGroupChanged = true;
             }
-            else if (!IncludeInSearch && m_parentScene.ExternalChecks.ExternalChecksCanMoveObject(objid,user))
+            else if (!IncludeInSearch && m_parentScene.Permissions.CanMoveObject(objid,user))
             {
                 obj.ParentGroup.RootPart.RemFlag(PrimFlags.JointWheel);
                 obj.ParentGroup.HasGroupChanged = true;
@@ -1665,7 +1665,7 @@ namespace OpenSim.Region.Environment.Scenes
 
             if (originPrim != null)
             {
-                if (m_parentScene.ExternalChecks.ExternalChecksCanDuplicateObject(originPrim.Children.Count, originPrim.UUID, AgentID, originPrim.AbsolutePosition))
+                if (m_parentScene.Permissions.CanDuplicateObject(originPrim.Children.Count, originPrim.UUID, AgentID, originPrim.AbsolutePosition))
                 {
                     SceneObjectGroup copy = originPrim.Copy(AgentID, GroupID, true);
                     copy.AbsolutePosition = copy.AbsolutePosition + offset;
diff --git a/OpenSim/Region/Environment/Scenes/SceneManager.cs b/OpenSim/Region/Environment/Scenes/SceneManager.cs
index 2af31d6..30dd497 100644
--- a/OpenSim/Region/Environment/Scenes/SceneManager.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneManager.cs
@@ -261,7 +261,7 @@ namespace OpenSim.Region.Environment.Scenes
 
         public void SetBypassPermissionsOnCurrentScene(bool bypassPermissions)
         {
-            ForEachCurrentScene(delegate(Scene scene) { scene.ExternalChecks.ExternalChecksSetBypassPermissions(bypassPermissions); });
+            ForEachCurrentScene(delegate(Scene scene) { scene.Permissions.SetBypassPermissions(bypassPermissions); });
         }
 
         private void ForEachCurrentScene(Action<Scene> func)
diff --git a/OpenSim/Region/Environment/Scenes/SceneObjectGroup.Inventory.cs b/OpenSim/Region/Environment/Scenes/SceneObjectGroup.Inventory.cs
index 9ca5564..62e680b 100644
--- a/OpenSim/Region/Environment/Scenes/SceneObjectGroup.Inventory.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneObjectGroup.Inventory.cs
@@ -157,7 +157,7 @@ namespace OpenSim.Region.Environment.Scenes
 
                 if (remoteClient != null &&
                         remoteClient.AgentId != part.OwnerID &&
-                        m_scene.ExternalChecks.ExternalChecksPropagatePermissions())
+                        m_scene.Permissions.PropagatePermissions())
                 {
                     taskItem.BasePermissions = item.BasePermissions &
                             item.NextPermissions;
diff --git a/OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs
index fcda37b..0eefda1 100644
--- a/OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs
@@ -1277,14 +1277,14 @@ namespace OpenSim.Region.Environment.Scenes
 
         public void SendFullUpdateToClient(IClientAPI remoteClient)
         {
-            SendPartFullUpdate(remoteClient, RootPart, m_scene.ExternalChecks.ExternalChecksGenerateClientFlags(remoteClient.AgentId, RootPart.UUID));
+            SendPartFullUpdate(remoteClient, RootPart, m_scene.Permissions.GenerateClientFlags(remoteClient.AgentId, RootPart.UUID));
 
             lock (m_parts)
             {
                 foreach (SceneObjectPart part in m_parts.Values)
                 {
                     if (part != RootPart)
-                        SendPartFullUpdate(remoteClient, part, m_scene.ExternalChecks.ExternalChecksGenerateClientFlags(remoteClient.AgentId, part.UUID));
+                        SendPartFullUpdate(remoteClient, part, m_scene.Permissions.GenerateClientFlags(remoteClient.AgentId, part.UUID));
                 }
             }
         }
@@ -1493,7 +1493,7 @@ namespace OpenSim.Region.Environment.Scenes
             if (part.OwnerID != cAgentID)
             {
                 // Apply Next Owner Permissions if we're not bypassing permissions
-                if (!m_scene.ExternalChecks.ExternalChecksBypassPermissions())
+                if (!m_scene.Permissions.BypassPermissions())
                     ApplyNextOwnerPermissions();
             }
 
diff --git a/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs b/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs
index 8a58e71..712cbac 100644
--- a/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs
@@ -2997,7 +2997,7 @@ if (m_shape != null) {
         public void UpdatePermissions(UUID AgentID, byte field, uint localID, uint mask, byte addRemTF)
         {
             bool set = addRemTF == 1;
-            bool god = m_parentGroup.Scene.ExternalChecks.ExternalChecksCanBeGodLike(AgentID);
+            bool god = m_parentGroup.Scene.Permissions.IsGod(AgentID);
 
             uint baseMask = _baseMask;
             if (god)
diff --git a/OpenSim/Region/Environment/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Environment/Scenes/SceneObjectPartInventory.cs
index 0a6f22c..aff1ef1 100644
--- a/OpenSim/Region/Environment/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneObjectPartInventory.cs
@@ -230,7 +230,7 @@ namespace OpenSim.Region.Environment.Scenes
             //     "Starting script {0}, {1} in prim {2}, {3}",
             //     item.Name, item.ItemID, Name, UUID);
 
-            if (!m_part.ParentGroup.Scene.ExternalChecks.ExternalChecksCanRunScript(item.ItemID, m_part.UUID, item.OwnerID))
+            if (!m_part.ParentGroup.Scene.Permissions.CanRunScript(item.ItemID, m_part.UUID, item.OwnerID))
                 return;
 
             m_part.AddFlag(PrimFlags.Scripted);
diff --git a/OpenSim/Region/Environment/Scenes/ScenePresence.cs b/OpenSim/Region/Environment/Scenes/ScenePresence.cs
index b293f9e..042a4fb 100644
--- a/OpenSim/Region/Environment/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Environment/Scenes/ScenePresence.cs
@@ -577,7 +577,7 @@ namespace OpenSim.Region.Environment.Scenes
 
         public uint GenerateClientFlags(UUID ObjectID)
         {
-            return m_scene.ExternalChecks.ExternalChecksGenerateClientFlags(m_uuid, ObjectID);
+            return m_scene.Permissions.GenerateClientFlags(m_uuid, ObjectID);
         }
 
         /// <summary>