* Attempt to make OpenSim.ini.example a bit more readable by

*   Some rearrangement within sections
*   Indenting section contents
* Also, correct indentation levels in PermissionsModule

1 files changed, 506 insertions, 506 deletions

diff --git a/OpenSim/Region/Environment/Modules/World/Permissions/PermissionsModule.cs b/OpenSim/Region/Environment/Modules/World/Permissions/PermissionsModule.cs
index 0585213..5d48cbd 100644
--- a/OpenSim/Region/Environment/Modules/World/Permissions/PermissionsModule.cs
+++ b/OpenSim/Region/Environment/Modules/World/Permissions/PermissionsModule.cs
@@ -552,683 +552,683 @@ namespace OpenSim.Region.Environment.Modules.World.Permissions
 #endregion
 
         #region Permission Checks
-            private bool CanAbandonParcel(UUID user, ILandObject parcel, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
-
-                return GenericParcelPermission(user, parcel);
-            }
+        private bool CanAbandonParcel(UUID user, ILandObject parcel, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-            private bool CanReclaimParcel(UUID user, ILandObject parcel, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+            return GenericParcelPermission(user, parcel);
+        }
 
-                return GenericParcelPermission(user, parcel);
-            }
+        private bool CanReclaimParcel(UUID user, ILandObject parcel, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-            private bool CanBeGodLike(UUID user, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+            return GenericParcelPermission(user, parcel);
+        }
 
-                return IsAdministrator(user);
-            }
+        private bool CanBeGodLike(UUID user, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-            private bool CanDuplicateObject(int objectCount, UUID objectID, UUID owner, Scene scene, Vector3 objectPosition)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+            return IsAdministrator(user);
+        }
 
-                if (!GenericObjectPermission(owner, objectID, true))
-                {
-                    //They can't even edit the object
-                    return false;
-                }
-                //If they can rez, they can duplicate
-                return CanRezObject(objectCount, owner, objectPosition, scene);
-            }
+        private bool CanDuplicateObject(int objectCount, UUID objectID, UUID owner, Scene scene, Vector3 objectPosition)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-            private bool CanDeleteObject(UUID objectID, UUID deleter, Scene scene)
+            if (!GenericObjectPermission(owner, objectID, true))
             {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
-
-                return GenericObjectPermission(deleter, objectID, false);
+                //They can't even edit the object
+                return false;
             }
+            //If they can rez, they can duplicate
+            return CanRezObject(objectCount, owner, objectPosition, scene);
+        }
 
-            private bool CanEditObject(UUID objectID, UUID editorID, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
-
+        private bool CanDeleteObject(UUID objectID, UUID deleter, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                return GenericObjectPermission(editorID, objectID, false);
-            }
+            return GenericObjectPermission(deleter, objectID, false);
+        }
 
-            private bool CanEditObjectInventory(UUID objectID, UUID editorID, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+        private bool CanEditObject(UUID objectID, UUID editorID, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                SceneObjectPart part = m_scene.GetSceneObjectPart(objectID);
 
-                // TODO: add group support!
-                //
-                if (part.OwnerID != editorID)
-                    return false;
-
-                return GenericObjectPermission(editorID, objectID, false);
-            }
+            return GenericObjectPermission(editorID, objectID, false);
+        }
 
-            private bool CanEditParcel(UUID user, ILandObject parcel, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+        private bool CanEditObjectInventory(UUID objectID, UUID editorID, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                return GenericParcelPermission(user, parcel);
-            }
+            SceneObjectPart part = m_scene.GetSceneObjectPart(objectID);
 
-            private bool CanEditScript(UUID script, UUID objectID, UUID user, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+            // TODO: add group support!
+            //
+            if (part.OwnerID != editorID)
+                return false;
 
-                // If you can view it, you can edit it
-                // There is no viewing a no mod script
-                //
-                return CanViewScript(script, objectID, user, scene);
-            }
+            return GenericObjectPermission(editorID, objectID, false);
+        }
 
-            private bool CanEditNotecard(UUID notecard, UUID objectID, UUID user, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+        private bool CanEditParcel(UUID user, ILandObject parcel, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                if (objectID == UUID.Zero) // User inventory
-                {
-                    CachedUserInfo userInfo =
-                            scene.CommsManager.UserProfileCacheService.GetUserDetails(user);
-                
-                    if (userInfo == null)
-                    {
-                        m_log.ErrorFormat("[PERMISSIONS]: Could not find user {0} for edit notecard check", user);
-                        return false;
-                    }                    
-                
+            return GenericParcelPermission(user, parcel);
+        }
 
-                    if (userInfo.RootFolder == null)
-                        return false;
+        private bool CanEditScript(UUID script, UUID objectID, UUID user, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                    InventoryItemBase assetRequestItem = userInfo.RootFolder.FindItem(notecard);
-                    if (assetRequestItem == null) // Library item
-                    {
-                        assetRequestItem = scene.CommsManager.UserProfileCacheService.LibraryRoot.FindItem(notecard);
+            // If you can view it, you can edit it
+            // There is no viewing a no mod script
+            //
+            return CanViewScript(script, objectID, user, scene);
+        }
 
-                        if (assetRequestItem != null) // Implicitly readable
-                            return true;
-                    }
+        private bool CanEditNotecard(UUID notecard, UUID objectID, UUID user, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                    // Notecards must be both mod and copy to be saveable
-                    // This is because of they're not copy, you can't read
-                    // them, and if they're not mod, well, then they're
-                    // not mod. Duh.
-                    //
-                    if ((assetRequestItem.CurrentPermissions &
-                            ((uint)PermissionMask.Modify |
-                            (uint)PermissionMask.Copy)) !=
-                            ((uint)PermissionMask.Modify |
-                            (uint)PermissionMask.Copy))
-                        return false;
-                }
-                else // Prim inventory
+            if (objectID == UUID.Zero) // User inventory
+            {
+                CachedUserInfo userInfo =
+                        scene.CommsManager.UserProfileCacheService.GetUserDetails(user);
+            
+                if (userInfo == null)
                 {
-                    SceneObjectPart part = scene.GetSceneObjectPart(objectID);
-
-                    if (part == null)
-                        return false;
-
-                    if (part.OwnerID != user)
-                        return false;
-
-                    if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
-                        return false;
-
-                    TaskInventoryItem ti = part.GetInventoryItem(notecard);
+                    m_log.ErrorFormat("[PERMISSIONS]: Could not find user {0} for edit notecard check", user);
+                    return false;
+                }                    
+            
 
-                    if (ti == null)
-                        return false;
+                if (userInfo.RootFolder == null)
+                    return false;
 
-                    if (ti.OwnerID != user)
-                        return false;
+                InventoryItemBase assetRequestItem = userInfo.RootFolder.FindItem(notecard);
+                if (assetRequestItem == null) // Library item
+                {
+                    assetRequestItem = scene.CommsManager.UserProfileCacheService.LibraryRoot.FindItem(notecard);
 
-                    // Require full perms
-                    if ((ti.CurrentPermissions &
-                            ((uint)PermissionMask.Modify |
-                            (uint)PermissionMask.Copy)) !=
-                            ((uint)PermissionMask.Modify |
-                            (uint)PermissionMask.Copy))
-                        return false;
+                    if (assetRequestItem != null) // Implicitly readable
+                        return true;
                 }
 
-                return true;
+                // Notecards must be both mod and copy to be saveable
+                // This is because of they're not copy, you can't read
+                // them, and if they're not mod, well, then they're
+                // not mod. Duh.
+                //
+                if ((assetRequestItem.CurrentPermissions &
+                        ((uint)PermissionMask.Modify |
+                        (uint)PermissionMask.Copy)) !=
+                        ((uint)PermissionMask.Modify |
+                        (uint)PermissionMask.Copy))
+                    return false;
             }
-
-            private bool CanInstantMessage(UUID user, UUID target, Scene startScene)
+            else // Prim inventory
             {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
-
+                SceneObjectPart part = scene.GetSceneObjectPart(objectID);
 
-                return GenericCommunicationPermission(user, target);
-            }
-
-            private bool CanInventoryTransfer(UUID user, UUID target, Scene startScene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+                if (part == null)
+                    return false;
 
-                return GenericCommunicationPermission(user, target);
-            }
+                if (part.OwnerID != user)
+                    return false;
 
-            private bool CanIssueEstateCommand(UUID user, Scene requestFromScene, bool ownerCommand)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+                if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
+                    return false;
 
-                if (IsAdministrator(user))
-                    return true;
+                TaskInventoryItem ti = part.GetInventoryItem(notecard);
 
-                if (m_scene.RegionInfo.EstateSettings.IsEstateOwner(user))
-                    return true;
+                if (ti == null)
+                    return false;
 
-                if (ownerCommand)
+                if (ti.OwnerID != user)
                     return false;
 
-                return GenericEstatePermission(user);
+                // Require full perms
+                if ((ti.CurrentPermissions &
+                        ((uint)PermissionMask.Modify |
+                        (uint)PermissionMask.Copy)) !=
+                        ((uint)PermissionMask.Modify |
+                        (uint)PermissionMask.Copy))
+                    return false;
             }
 
-            private bool CanMoveObject(UUID objectID, UUID moverID, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions)
-                {
-                    SceneObjectPart part = scene.GetSceneObjectPart(objectID);
-                    if (part.OwnerID != moverID)
-                    {
-                        if (part.ParentGroup != null && !part.ParentGroup.IsDeleted)
-                        {
-                            if (part.ParentGroup.IsAttachment)
-                                return false;
-                        }
-                    }
-                    return m_bypassPermissionsValue;
-                }
+            return true;
+        }
 
-                bool permission = GenericObjectPermission(moverID, objectID, true);
-                if (!permission)
-                {
-                    if (!m_scene.Entities.ContainsKey(objectID))
-                    {
-                        return false;
-                    }
+        private bool CanInstantMessage(UUID user, UUID target, Scene startScene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                    // The client
-                    // may request to edit linked parts, and therefore, it needs
-                    // to also check for SceneObjectPart
 
-                    // If it's not an object, we cant edit it.
-                    if ((!(m_scene.Entities[objectID] is SceneObjectGroup)))
-                    {
-                        return false;
-                    }
+            return GenericCommunicationPermission(user, target);
+        }
 
+        private bool CanInventoryTransfer(UUID user, UUID target, Scene startScene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                    SceneObjectGroup task = (SceneObjectGroup)m_scene.Entities[objectID];
+            return GenericCommunicationPermission(user, target);
+        }
 
+        private bool CanIssueEstateCommand(UUID user, Scene requestFromScene, bool ownerCommand)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                    // UUID taskOwner = null;
-                    // Added this because at this point in time it wouldn't be wise for
-                    // the administrator object permissions to take effect.
-                    // UUID objectOwner = task.OwnerID;
+            if (IsAdministrator(user))
+                return true;
 
-                    // Anyone can move
-                    if ((task.RootPart.EveryoneMask & PERM_MOVE) != 0)
-                        permission = true;
+            if (m_scene.RegionInfo.EstateSettings.IsEstateOwner(user))
+                return true;
 
-                    // Locked
-                    if ((task.RootPart.OwnerMask & PERM_LOCKED) == 0)
-                        permission = false;
+            if (ownerCommand)
+                return false;
 
-                }
-                else
-                {
-                    bool locked = false;
-                    if (!m_scene.Entities.ContainsKey(objectID))
-                    {
-                        return false;
-                    }
+            return GenericEstatePermission(user);
+        }
 
-                    // If it's not an object, we cant edit it.
-                    if ((!(m_scene.Entities[objectID] is SceneObjectGroup)))
+        private bool CanMoveObject(UUID objectID, UUID moverID, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions)
+            {
+                SceneObjectPart part = scene.GetSceneObjectPart(objectID);
+                if (part.OwnerID != moverID)
+                {
+                    if (part.ParentGroup != null && !part.ParentGroup.IsDeleted)
                     {
-                        return false;
+                        if (part.ParentGroup.IsAttachment)
+                            return false;
                     }
-
-
-                    SceneObjectGroup group = (SceneObjectGroup)m_scene.Entities[objectID];
-
-                    UUID objectOwner = group.OwnerID;
-                    locked = ((group.RootPart.OwnerMask & PERM_LOCKED) == 0);
-
-
-                    // This is an exception to the generic object permission.
-                    // Administrators who lock their objects should not be able to move them,
-                    // however generic object permission should return true.
-                    // This keeps locked objects from being affected by random click + drag actions by accident
-                    // and allows the administrator to grab or delete a locked object.
-
-                    // Administrators and estate managers are still able to click+grab locked objects not
-                    // owned by them in the scene
-                    // This is by design.
-
-                    if (locked && (moverID == objectOwner))
-                        return false;
                 }
-                return permission;
+                return m_bypassPermissionsValue;
             }
 
-            private bool CanObjectEntry(UUID objectID, Vector3 newPoint, Scene scene)
+            bool permission = GenericObjectPermission(moverID, objectID, true);
+            if (!permission)
             {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
-
-                if ((newPoint.X > 257f || newPoint.X < -1f || newPoint.Y > 257f || newPoint.Y < -1f))
+                if (!m_scene.Entities.ContainsKey(objectID))
                 {
-                    return true;
+                    return false;
                 }
 
-                ILandObject land = m_scene.LandChannel.GetLandObject(newPoint.X, newPoint.Y);
+                // The client
+                // may request to edit linked parts, and therefore, it needs
+                // to also check for SceneObjectPart
 
-                if (land == null)
+                // If it's not an object, we cant edit it.
+                if ((!(m_scene.Entities[objectID] is SceneObjectGroup)))
                 {
                     return false;
                 }
 
-                if ((land.landData.Flags & ((int)Parcel.ParcelFlags.AllowAPrimitiveEntry)) != 0)
-                {
-                    return true;
-                }
 
-                //TODO: check for group rights
+                SceneObjectGroup task = (SceneObjectGroup)m_scene.Entities[objectID];
+
+
+                // UUID taskOwner = null;
+                // Added this because at this point in time it wouldn't be wise for
+                // the administrator object permissions to take effect.
+                // UUID objectOwner = task.OwnerID;
 
+                // Anyone can move
+                if ((task.RootPart.EveryoneMask & PERM_MOVE) != 0)
+                    permission = true;
+
+                // Locked
+                if ((task.RootPart.OwnerMask & PERM_LOCKED) == 0)
+                    permission = false;
+
+            }
+            else
+            {
+                bool locked = false;
                 if (!m_scene.Entities.ContainsKey(objectID))
                 {
                     return false;
                 }
 
                 // If it's not an object, we cant edit it.
-                if (!(m_scene.Entities[objectID] is SceneObjectGroup))
+                if ((!(m_scene.Entities[objectID] is SceneObjectGroup)))
                 {
                     return false;
                 }
 
-                SceneObjectGroup task = (SceneObjectGroup)m_scene.Entities[objectID];
 
-                if (GenericParcelPermission(task.OwnerID, newPoint))
-                {
-                    return true;
-                }
+                SceneObjectGroup group = (SceneObjectGroup)m_scene.Entities[objectID];
+
+                UUID objectOwner = group.OwnerID;
+                locked = ((group.RootPart.OwnerMask & PERM_LOCKED) == 0);
+
+
+                // This is an exception to the generic object permission.
+                // Administrators who lock their objects should not be able to move them,
+                // however generic object permission should return true.
+                // This keeps locked objects from being affected by random click + drag actions by accident
+                // and allows the administrator to grab or delete a locked object.
+
+                // Administrators and estate managers are still able to click+grab locked objects not
+                // owned by them in the scene
+                // This is by design.
 
-                //Otherwise, false!
+                if (locked && (moverID == objectOwner))
+                    return false;
+            }
+            return permission;
+        }
+
+        private bool CanObjectEntry(UUID objectID, Vector3 newPoint, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
+
+            if ((newPoint.X > 257f || newPoint.X < -1f || newPoint.Y > 257f || newPoint.Y < -1f))
+            {
+                return true;
+            }
+
+            ILandObject land = m_scene.LandChannel.GetLandObject(newPoint.X, newPoint.Y);
+
+            if (land == null)
+            {
                 return false;
             }
 
-            private bool CanReturnObject(UUID objectID, UUID returnerID, Scene scene)
+            if ((land.landData.Flags & ((int)Parcel.ParcelFlags.AllowAPrimitiveEntry)) != 0)
             {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+                return true;
+            }
+
+            //TODO: check for group rights
 
-                return GenericObjectPermission(returnerID, objectID, false);
+            if (!m_scene.Entities.ContainsKey(objectID))
+            {
+                return false;
             }
 
-            private bool CanRezObject(int objectCount, UUID owner, Vector3 objectPosition, Scene scene)
+            // If it's not an object, we cant edit it.
+            if (!(m_scene.Entities[objectID] is SceneObjectGroup))
             {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+                return false;
+            }
 
-                bool permission = false;
+            SceneObjectGroup task = (SceneObjectGroup)m_scene.Entities[objectID];
 
-                ILandObject land = m_scene.LandChannel.GetLandObject(objectPosition.X, objectPosition.Y);
-                if (land == null) return false;
+            if (GenericParcelPermission(task.OwnerID, newPoint))
+            {
+                return true;
+            }
 
-                if ((land.landData.Flags & ((int)Parcel.ParcelFlags.CreateObjects)) ==
-                    (int)Parcel.ParcelFlags.CreateObjects)
-                    permission = true;
+            //Otherwise, false!
+            return false;
+        }
 
-                //TODO: check for group rights
+        private bool CanReturnObject(UUID objectID, UUID returnerID, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                if (IsAdministrator(owner))
-                {
-                    permission = true;
-                }
+            return GenericObjectPermission(returnerID, objectID, false);
+        }
 
-                if (GenericParcelPermission(owner, objectPosition))
-                {
-                    permission = true;
-                }
+        private bool CanRezObject(int objectCount, UUID owner, Vector3 objectPosition, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                return permission;
-            }
+            bool permission = false;
 
-            private bool CanRunConsoleCommand(UUID user, Scene requestFromScene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+            ILandObject land = m_scene.LandChannel.GetLandObject(objectPosition.X, objectPosition.Y);
+            if (land == null) return false;
 
+            if ((land.landData.Flags & ((int)Parcel.ParcelFlags.CreateObjects)) ==
+                (int)Parcel.ParcelFlags.CreateObjects)
+                permission = true;
 
-                return IsAdministrator(user);
-            }
+            //TODO: check for group rights
 
-            private bool CanRunScript(UUID script, UUID objectID, UUID user, Scene scene)
+            if (IsAdministrator(owner))
             {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
-
-                return true;
+                permission = true;
             }
 
-            private bool CanSellParcel(UUID user, ILandObject parcel, Scene scene)
+            if (GenericParcelPermission(owner, objectPosition))
             {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
-
-                return GenericParcelPermission(user, parcel);
+                permission = true;
             }
 
-            private bool CanTakeObject(UUID objectID, UUID stealer, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+            return permission;
+        }
 
-                return GenericObjectPermission(stealer,objectID, false);
-            }
+        private bool CanRunConsoleCommand(UUID user, Scene requestFromScene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-            private bool CanTakeCopyObject(UUID objectID, UUID userID, Scene inScene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                bool permission = GenericObjectPermission(userID, objectID,false);
-                if (!permission)
-                {
-                    if (!m_scene.Entities.ContainsKey(objectID))
-                    {
-                        return false;
-                    }
+            return IsAdministrator(user);
+        }
 
-                    // If it's not an object, we cant edit it.
-                    if (!(m_scene.Entities[objectID] is SceneObjectGroup))
-                    {
-                        return false;
-                    }
+        private bool CanRunScript(UUID script, UUID objectID, UUID user, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                    SceneObjectGroup task = (SceneObjectGroup)m_scene.Entities[objectID];
-                    // UUID taskOwner = null;
-                    // Added this because at this point in time it wouldn't be wise for
-                    // the administrator object permissions to take effect.
-                    // UUID objectOwner = task.OwnerID;
+            return true;
+        }
 
+        private bool CanSellParcel(UUID user, ILandObject parcel, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                    if ((task.RootPart.EveryoneMask & PERM_COPY) != 0)
-                        permission = true;
-                }
-                return permission;
-            }
+            return GenericParcelPermission(user, parcel);
+        }
 
-            private bool CanTerraformLand(UUID user, Vector3 position, Scene requestFromScene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+        private bool CanTakeObject(UUID objectID, UUID stealer, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                // Estate override
-                if (GenericEstatePermission(user))
-                    return true;
+            return GenericObjectPermission(stealer,objectID, false);
+        }
 
-                float X = position.X;
-                float Y = position.Y;
+        private bool CanTakeCopyObject(UUID objectID, UUID userID, Scene inScene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                if (X > 255)
-                    X = 255;
-                if (Y > 255)
-                    Y = 255;
-                if (X < 0)
-                    X = 0;
-                if (Y < 0)
-                    Y = 0;
+            bool permission = GenericObjectPermission(userID, objectID,false);
+            if (!permission)
+            {
+                if (!m_scene.Entities.ContainsKey(objectID))
+                {
+                    return false;
+                }
 
-                ILandObject parcel = m_scene.LandChannel.GetLandObject(X, Y);
-                if (parcel == null)
+                // If it's not an object, we cant edit it.
+                if (!(m_scene.Entities[objectID] is SceneObjectGroup))
+                {
                     return false;
+                }
 
-                // Others allowed to terraform?
-                if ((parcel.landData.Flags & ((int)Parcel.ParcelFlags.AllowTerraform)) != 0)
-                    return true;
+                SceneObjectGroup task = (SceneObjectGroup)m_scene.Entities[objectID];
+                // UUID taskOwner = null;
+                // Added this because at this point in time it wouldn't be wise for
+                // the administrator object permissions to take effect.
+                // UUID objectOwner = task.OwnerID;
 
-                // Land owner can terraform too
-                if (parcel != null && GenericParcelPermission(user, parcel))
-                    return true;
 
-                return false;
+                if ((task.RootPart.EveryoneMask & PERM_COPY) != 0)
+                    permission = true;
             }
+            return permission;
+        }
 
-            private bool CanViewScript(UUID script, UUID objectID, UUID user, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+        private bool CanTerraformLand(UUID user, Vector3 position, Scene requestFromScene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                if (objectID == UUID.Zero) // User inventory
-                {
-                    CachedUserInfo userInfo =
-                            scene.CommsManager.UserProfileCacheService.GetUserDetails(user);
-                
-                    if (userInfo == null)
-                    {
-                        m_log.ErrorFormat("[PERMISSIONS]: Could not find user {0} for administrator check", user);
-                        return false;
-                    }    
+            // Estate override
+            if (GenericEstatePermission(user))
+                return true;
 
-                    if (userInfo.RootFolder == null)
-                        return false;
+            float X = position.X;
+            float Y = position.Y;
 
-                    InventoryItemBase assetRequestItem = userInfo.RootFolder.FindItem(script);
-                    if (assetRequestItem == null) // Library item
-                    {
-                        assetRequestItem = m_scene.CommsManager.UserProfileCacheService.LibraryRoot.FindItem(script);
+            if (X > 255)
+                X = 255;
+            if (Y > 255)
+                Y = 255;
+            if (X < 0)
+                X = 0;
+            if (Y < 0)
+                Y = 0;
 
-                        if (assetRequestItem != null) // Implicitly readable
-                            return true;
-                    }
+            ILandObject parcel = m_scene.LandChannel.GetLandObject(X, Y);
+            if (parcel == null)
+                return false;
 
-                    // SL is rather harebrained here. In SL, a script you
-                    // have mod/copy no trans is readable. This subverts
-                    // permissions, but is used in some products, most
-                    // notably Hippo door plugin and HippoRent 5 networked
-                    // prim counter.
-                    // To enable this broken SL-ism, remove Transfer from
-                    // the below expressions.
-                    // Trying to improve on SL perms by making a script
-                    // readable only if it's really full perms
-                    //
-                    if ((assetRequestItem.CurrentPermissions &
-                            ((uint)PermissionMask.Modify |
-                            (uint)PermissionMask.Copy |
-                            (uint)PermissionMask.Transfer)) !=
-                            ((uint)PermissionMask.Modify |
-                            (uint)PermissionMask.Copy |
-                            (uint)PermissionMask.Transfer))
-                        return false;
-                }
-                else // Prim inventory
-                {
-                    SceneObjectPart part = scene.GetSceneObjectPart(objectID);
+            // Others allowed to terraform?
+            if ((parcel.landData.Flags & ((int)Parcel.ParcelFlags.AllowTerraform)) != 0)
+                return true;
 
-                    if (part == null)
-                        return false;
+            // Land owner can terraform too
+            if (parcel != null && GenericParcelPermission(user, parcel))
+                return true;
 
-                    if (part.OwnerID != user)
-                        return false;
+            return false;
+        }
 
-                    if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
-                        return false;
+        private bool CanViewScript(UUID script, UUID objectID, UUID user, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                    TaskInventoryItem ti = part.GetInventoryItem(script);
+            if (objectID == UUID.Zero) // User inventory
+            {
+                CachedUserInfo userInfo =
+                        scene.CommsManager.UserProfileCacheService.GetUserDetails(user);
+            
+                if (userInfo == null)
+                {
+                    m_log.ErrorFormat("[PERMISSIONS]: Could not find user {0} for administrator check", user);
+                    return false;
+                }    
 
-                    if (ti == null)
-                        return false;
+                if (userInfo.RootFolder == null)
+                    return false;
 
-                    if (ti.OwnerID != user)
-                        return false;
+                InventoryItemBase assetRequestItem = userInfo.RootFolder.FindItem(script);
+                if (assetRequestItem == null) // Library item
+                {
+                    assetRequestItem = m_scene.CommsManager.UserProfileCacheService.LibraryRoot.FindItem(script);
 
-                    // Require full perms
-                    if ((ti.CurrentPermissions &
-                            ((uint)PermissionMask.Modify |
-                            (uint)PermissionMask.Copy |
-                            (uint)PermissionMask.Transfer)) !=
-                            ((uint)PermissionMask.Modify |
-                            (uint)PermissionMask.Copy |
-                            (uint)PermissionMask.Transfer))
-                        return false;
+                    if (assetRequestItem != null) // Implicitly readable
+                        return true;
                 }
 
-                return true;
+                // SL is rather harebrained here. In SL, a script you
+                // have mod/copy no trans is readable. This subverts
+                // permissions, but is used in some products, most
+                // notably Hippo door plugin and HippoRent 5 networked
+                // prim counter.
+                // To enable this broken SL-ism, remove Transfer from
+                // the below expressions.
+                // Trying to improve on SL perms by making a script
+                // readable only if it's really full perms
+                //
+                if ((assetRequestItem.CurrentPermissions &
+                        ((uint)PermissionMask.Modify |
+                        (uint)PermissionMask.Copy |
+                        (uint)PermissionMask.Transfer)) !=
+                        ((uint)PermissionMask.Modify |
+                        (uint)PermissionMask.Copy |
+                        (uint)PermissionMask.Transfer))
+                    return false;
             }
-
-            private bool CanViewNotecard(UUID notecard, UUID objectID, UUID user, Scene scene)
+            else // Prim inventory
             {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+                SceneObjectPart part = scene.GetSceneObjectPart(objectID);
 
-                if (objectID == UUID.Zero) // User inventory
-                {
-                    CachedUserInfo userInfo =
-                            scene.CommsManager.UserProfileCacheService.GetUserDetails(user);
-                
-                    if (userInfo == null)
-                    {
-                        m_log.ErrorFormat("[PERMISSIONS]: Could not find user {0} for view notecard check", user);
-                        return false;
-                    }    
+                if (part == null)
+                    return false;
 
-                    if (userInfo.RootFolder == null)
-                        return false;
+                if (part.OwnerID != user)
+                    return false;
 
-                    InventoryItemBase assetRequestItem = userInfo.RootFolder.FindItem(notecard);
-                    if (assetRequestItem == null) // Library item
-                    {
-                        assetRequestItem = m_scene.CommsManager.UserProfileCacheService.LibraryRoot.FindItem(notecard);
+                if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
+                    return false;
 
-                        if (assetRequestItem != null) // Implicitly readable
-                            return true;
-                    }
+                TaskInventoryItem ti = part.GetInventoryItem(script);
 
-                    // Notecards are always readable unless no copy
-                    //
-                    if ((assetRequestItem.CurrentPermissions &
-                            (uint)PermissionMask.Copy) !=
-                            (uint)PermissionMask.Copy)
-                        return false;
-                }
-                else // Prim inventory
-                {
-                    SceneObjectPart part = scene.GetSceneObjectPart(objectID);
+                if (ti == null)
+                    return false;
+
+                if (ti.OwnerID != user)
+                    return false;
 
-                    if (part == null)
-                        return false;
+                // Require full perms
+                if ((ti.CurrentPermissions &
+                        ((uint)PermissionMask.Modify |
+                        (uint)PermissionMask.Copy |
+                        (uint)PermissionMask.Transfer)) !=
+                        ((uint)PermissionMask.Modify |
+                        (uint)PermissionMask.Copy |
+                        (uint)PermissionMask.Transfer))
+                    return false;
+            }
 
-                    if (part.OwnerID != user)
-                        return false;
+            return true;
+        }
 
-                    if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
-                        return false;
+        private bool CanViewNotecard(UUID notecard, UUID objectID, UUID user, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                    TaskInventoryItem ti = part.GetInventoryItem(notecard);
+            if (objectID == UUID.Zero) // User inventory
+            {
+                CachedUserInfo userInfo =
+                        scene.CommsManager.UserProfileCacheService.GetUserDetails(user);
+            
+                if (userInfo == null)
+                {
+                    m_log.ErrorFormat("[PERMISSIONS]: Could not find user {0} for view notecard check", user);
+                    return false;
+                }    
 
-                    if (ti == null)
-                        return false;
+                if (userInfo.RootFolder == null)
+                    return false;
 
-                    if (ti.OwnerID != user)
-                        return false;
+                InventoryItemBase assetRequestItem = userInfo.RootFolder.FindItem(notecard);
+                if (assetRequestItem == null) // Library item
+                {
+                    assetRequestItem = m_scene.CommsManager.UserProfileCacheService.LibraryRoot.FindItem(notecard);
 
-                    // Notecards are always readable unless no copy
-                    //
-                    if ((ti.CurrentPermissions &
-                            (uint)PermissionMask.Copy) !=
-                            (uint)PermissionMask.Copy)
-                        return false;
+                    if (assetRequestItem != null) // Implicitly readable
+                        return true;
                 }
 
-                return true;
+                // Notecards are always readable unless no copy
+                //
+                if ((assetRequestItem.CurrentPermissions &
+                        (uint)PermissionMask.Copy) !=
+                        (uint)PermissionMask.Copy)
+                    return false;
             }
+            else // Prim inventory
+            {
+                SceneObjectPart part = scene.GetSceneObjectPart(objectID);
 
-        #endregion
+                if (part == null)
+                    return false;
 
-            public bool CanLinkObject(UUID userID, UUID objectID)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+                if (part.OwnerID != user)
+                    return false;
 
-                return true;
-            }
+                if ((part.OwnerMask & (uint)PermissionMask.Modify) == 0)
+                    return false;
 
-            public bool CanDelinkObject(UUID userID, UUID objectID)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+                TaskInventoryItem ti = part.GetInventoryItem(notecard);
 
-                return true;
-            }
+                if (ti == null)
+                    return false;
 
-            public bool CanBuyLand(UUID userID, ILandObject parcel, Scene scene)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+                if (ti.OwnerID != user)
+                    return false;
 
-                return true;
+                // Notecards are always readable unless no copy
+                //
+                if ((ti.CurrentPermissions &
+                        (uint)PermissionMask.Copy) !=
+                        (uint)PermissionMask.Copy)
+                    return false;
             }
 
-            public bool CanCopyInventory(UUID itemID, UUID objectID, UUID userID)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+            return true;
+        }
 
-                return true;
-            }
+    #endregion
 
-            public bool CanDeleteInventory(UUID itemID, UUID objectID, UUID userID)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+        public bool CanLinkObject(UUID userID, UUID objectID)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                return true;
-            }
+            return true;
+        }
 
-            public bool CanCreateInventory(uint invType, UUID objectID, UUID userID)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+        public bool CanDelinkObject(UUID userID, UUID objectID)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                return true;
-            }
+            return true;
+        }
 
-            public bool CanTeleport(UUID userID)
-            {
-                DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
-                if (m_bypassPermissions) return m_bypassPermissionsValue;
+        public bool CanBuyLand(UUID userID, ILandObject parcel, Scene scene)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-                return true;
-            }
+            return true;
+        }
+
+        public bool CanCopyInventory(UUID itemID, UUID objectID, UUID userID)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
+
+            return true;
+        }
+
+        public bool CanDeleteInventory(UUID itemID, UUID objectID, UUID userID)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
+
+            return true;
+        }
+
+        public bool CanCreateInventory(uint invType, UUID objectID, UUID userID)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
+
+            return true;
+        }
+
+        public bool CanTeleport(UUID userID)
+        {
+            DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
+            if (m_bypassPermissions) return m_bypassPermissionsValue;
+
+            return true;
+        }
     }
 
 }