From 85a9834ed84f33d3610499914fa3168a8eebce6d Mon Sep 17 00:00:00 2001 From: Teravus Ovares Date: Sun, 10 Feb 2008 10:55:57 +0000 Subject: * A lot of ugly permissions updates. ** Created SendFullUpdateToAllClientsExcept(LLUUID) so that permission updates /appear/ to apply immediately ** Separated out the ObjectFlags and the Permission Flags. They're related but not the same ** Added a hack routine to add *back* the objectflags to the client flags because the client hates the way we're doing object permissions ** Updated the clientflags routine to properly tell the client when they can't edit admin objects (objects owned by the sim administrator) even when they're an estate manager(why? >.< argh!) ** Fixed a null sim administrator/estate manager/user from causing permissions to return false even when it should return true. ** Re-added ObjectModify hack to allow collaboration with the allow anyone to move checkbox until we get group permissions done. --- OpenSim/Region/Environment/PermissionManager.cs | 164 +++++++++++++++++------- 1 file changed, 118 insertions(+), 46 deletions(-) (limited to 'OpenSim/Region/Environment/PermissionManager.cs') diff --git a/OpenSim/Region/Environment/PermissionManager.cs b/OpenSim/Region/Environment/PermissionManager.cs index 7cf89b0..5cd2b81 100644 --- a/OpenSim/Region/Environment/PermissionManager.cs +++ b/OpenSim/Region/Environment/PermissionManager.cs @@ -80,7 +80,13 @@ namespace OpenSim.Region.Environment return true; } - return m_scene.RegionInfo.MasterAvatarAssignedUUID == user; + // If there is no master avatar, return false + if (m_scene.RegionInfo.MasterAvatarAssignedUUID != null) + { + return m_scene.RegionInfo.MasterAvatarAssignedUUID == user; + } + + return false; } public virtual bool IsEstateManager(LLUUID user) @@ -89,13 +95,20 @@ namespace OpenSim.Region.Environment { return true; } - - LLUUID[] estatemanagers = m_scene.RegionInfo.EstateSettings.estateManagers; - for (int i = 0; i < estatemanagers.Length; i++) + if (user != null) { - if (estatemanagers[i] == user) - return true; + LLUUID[] estatemanagers = m_scene.RegionInfo.EstateSettings.estateManagers; + for (int i = 0; i < estatemanagers.Length; i++) + { + if (estatemanagers[i] == user) + return true; + } } + // The below is commented out because logically it happens anyway. It's left in for readability + //else + //{ + //return false; + //} return false; } @@ -153,6 +166,18 @@ namespace OpenSim.Region.Environment public virtual uint GenerateClientFlags(LLUUID user, LLUUID objID) { + + // Here's the way this works, + // ObjectFlags and Permission flags are two different enumerations + // ObjectFlags, however, tells the client to change what it will allow the user to do. + // So, that means that all of the permissions type ObjectFlags are /temporary/ and only + // supposed to be set when customizing the objectflags for the client. + + // These temporary objectflags get computed and added in this function based on the + // Permission mask that's appropriate! + // Outside of this method, they should never be added to objectflags! + // -teravus + if (!m_scene.Entities.ContainsKey(objID)) { return 0; @@ -170,10 +195,38 @@ namespace OpenSim.Region.Environment // the administrator object permissions to take effect. LLUUID objectOwner = task.OwnerID; - uint objectOwnerMask = task.RootPart.ObjectFlags; - objectOwnerMask = ApplyObjectModifyMasks(task.RootPart.OwnerMask, objectOwnerMask); + uint objflags = task.RootPart.ObjectFlags; + + + // Remove any of the objectFlags that are temporary. These will get added back if appropriate + // in the next bit of code + + objflags &= (uint)LLObject.ObjectFlags.ObjectCopy; // Tells client you can copy the object + objflags &= (uint)LLObject.ObjectFlags.ObjectModify; // tells client you can modify the object + objflags &= (uint)LLObject.ObjectFlags.ObjectMove; // tells client that you can move the object (only, no mod) + objflags &= (uint)LLObject.ObjectFlags.ObjectTransfer; // tells the client that you can /take/ the object if you don't own it + objflags &= (uint)LLObject.ObjectFlags.ObjectYouOwner; // Tells client that you're the owner of the object + objflags &= (uint)LLObject.ObjectFlags.ObjectYouOfficer; // Tells client that you've got group object editing permission. Used when ObjectGroupOwned is set + + + // Creating the three ObjectFlags options for this method to choose from. + bool tasklocked = task.GetLocked(); // more debug needed to apply this, so we're going to set this to false for now + tasklocked = false; - uint objectEveryoneMask = task.RootPart.ObjectFlags | task.RootPart.EveryoneMask; + uint objectOwnerMask = ApplyObjectModifyMasks(task.RootPart.OwnerMask, objflags, tasklocked); + objectOwnerMask = AddBackBrokenObjectProperties(task.RootPart, objectOwnerMask); + + objectOwnerMask |= (uint)LLObject.ObjectFlags.ObjectYouOwner; + + uint objectGroupMask = ApplyObjectModifyMasks(task.RootPart.GroupMask, objflags, tasklocked); + objectGroupMask = AddBackBrokenObjectProperties(task.RootPart,objectGroupMask); + + uint objectEveryoneMask = ApplyObjectModifyMasks(task.RootPart.EveryoneMask, objflags, tasklocked); + objectEveryoneMask = AddBackBrokenObjectProperties(task.RootPart,objectEveryoneMask); + + // Hack to allow collaboration until Groups and Group Permissions are implemented + if ((objectEveryoneMask & (uint)LLObject.ObjectFlags.ObjectMove) != 0) + objectEveryoneMask |= (uint)LLObject.ObjectFlags.ObjectModify; if (m_bypassPermissions) return objectOwnerMask; @@ -181,7 +234,6 @@ namespace OpenSim.Region.Environment // Object owners should be able to edit their own content if (user == objectOwner) { - objectOwnerMask |= (uint)LLObject.ObjectFlags.ObjectYouOwner; return objectOwnerMask; } @@ -189,58 +241,70 @@ namespace OpenSim.Region.Environment Land parcel = m_scene.LandManager.getLandObject(task.AbsolutePosition.X, task.AbsolutePosition.Y); if (parcel != null && parcel.landData.ownerID == user) return objectOwnerMask; - + + // Admin objects should not be editable by the above + if (IsAdministrator(objectOwner)) + return objectEveryoneMask; + // Estate users should be able to edit anything in the sim if (IsEstateManager(user)) return objectOwnerMask; - // Admin objects should not be editable by the above - if (IsAdministrator(taskOwner)) - return objectEveryoneMask; + // Admin should be able to edit anything in the sim (including admin objects) if (IsAdministrator(user)) return objectOwnerMask; - if (((objectEveryoneMask & PERM_MOVE) != 0) || ((objectEveryoneMask & PERM_COPY) != 0)) - { - if ((objectEveryoneMask & PERM_MOVE) != 0) - objectOwnerMask &= ~PERM_MOVE; - if ((objectEveryoneMask & PERM_COPY) != 0) - objectOwnerMask &= ~PERM_COPY; + return objectEveryoneMask; + } + private uint AddBackBrokenObjectProperties(SceneObjectPart task, uint objectmask) + { + if ((task.ObjectFlags & (uint)LLObject.ObjectFlags.Physics) != 0) + objectmask |= (uint)LLObject.ObjectFlags.Physics; - objectOwnerMask &= ~PERM_MODIFY; - objectOwnerMask &= ~PERM_TRANS; + if ((task.ObjectFlags & (uint)LLObject.ObjectFlags.Scripted) != 0) + objectmask |= (uint)LLObject.ObjectFlags.Scripted; - return objectOwnerMask; - } - return objectEveryoneMask; + if ((task.ObjectFlags & (uint)LLObject.ObjectFlags.TemporaryOnRez) != 0) + objectmask |= (uint)LLObject.ObjectFlags.TemporaryOnRez; + + if ((task.ObjectFlags & (uint)LLObject.ObjectFlags.Phantom) != 0) + objectmask |= (uint)LLObject.ObjectFlags.Phantom; + + return objectmask; } - private uint ApplyObjectModifyMasks(uint parentMask, uint objectOwnerMask) + private uint ApplyObjectModifyMasks(uint setPermissionMask, uint objectFlagsMask, bool locked) { - if ((parentMask & (uint)PermissionMask.Copy) != 0) + // We are adding the temporary objectflags to the object's objectflags based on the + // permission flag given. These change the F flags on the client. + if (!locked) { - objectOwnerMask |= (uint)LLObject.ObjectFlags.ObjectCopy; - } - if ((parentMask & (uint)PermissionMask.Move) != 0) - { - objectOwnerMask |= (uint)LLObject.ObjectFlags.ObjectMove; - } + if ((setPermissionMask & (uint)PermissionMask.Copy) != 0) + { + objectFlagsMask |= (uint)LLObject.ObjectFlags.ObjectCopy; + } - if ((parentMask & (uint)PermissionMask.Modify) != 0) - { - objectOwnerMask |= (uint)LLObject.ObjectFlags.ObjectModify; - } + if ((setPermissionMask & (uint)PermissionMask.Move) != 0) + { + objectFlagsMask |= (uint)LLObject.ObjectFlags.ObjectMove; + } - if ((parentMask & (uint)PermissionMask.Transfer) != 0) - { - objectOwnerMask |= (uint)LLObject.ObjectFlags.ObjectTransfer; + if ((setPermissionMask & (uint)PermissionMask.Modify) != 0) + { + objectFlagsMask |= (uint)LLObject.ObjectFlags.ObjectModify; + } + + if ((setPermissionMask & (uint)PermissionMask.Transfer) != 0) + { + objectFlagsMask |= (uint)LLObject.ObjectFlags.ObjectTransfer; + } } - return objectOwnerMask; + return objectFlagsMask; } protected virtual bool GenericObjectPermission(LLUUID currentUser, LLUUID objId) @@ -254,13 +318,14 @@ namespace OpenSim.Region.Environment } // If it's not an object, we cant edit it. - if (!(m_scene.Entities[objId] is SceneObjectGroup)) + if ((!(m_scene.Entities[objId] is SceneObjectGroup))) { return false; } - SceneObjectGroup group = (SceneObjectGroup) m_scene.Entities[objId]; - + + SceneObjectGroup group = (SceneObjectGroup)m_scene.Entities[objId]; + LLUUID objectOwner = group.OwnerID; // Object owners should be able to edit their own content @@ -323,13 +388,20 @@ namespace OpenSim.Region.Environment return false; } + // 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[obj] is SceneObjectGroup)) + if ((!(m_scene.Entities[obj] is SceneObjectGroup))) { return false; } - SceneObjectGroup task = (SceneObjectGroup) m_scene.Entities[obj]; + + SceneObjectGroup task = (SceneObjectGroup)m_scene.Entities[obj]; + + LLUUID taskOwner = null; // Added this because at this point in time it wouldn't be wise for // the administrator object permissions to take effect. -- cgit v1.1