RemoveQualifiedAces()

bool System.Security.AccessControl.CommonAcl.RemoveQualifiedAces ( SecurityIdentifier sid, AceQualifier qualifier, int accessMask, AceFlags flags, bool saclSemantics, ObjectAceFlags objectFlags, Guid objectType, Guid inheritedObjectType )

inlinepackageinherited

Definition at line 894 of file CommonAcl.cs.

    {
        if (accessMask == 0)
        {
            throw new ArgumentException(System.SR.Argument_ArgumentZero, "accessMask");
        }
        if (qualifier == AceQualifier.SystemAudit && (flags & AceFlags.AuditFlags) == 0)
        {
            throw new ArgumentException(System.SR.Arg_EnumAtLeastOneFlag, "flags");
        }
        if (sid == null)
        {
            throw new ArgumentNullException("sid");
        }
        ThrowIfNotCanonical();
        bool flag = true;
        bool flag2 = true;
        int num = accessMask;
        AceFlags aceFlags = flags;
        byte[] binaryForm = new byte[BinaryLength];
        GetBinaryForm(binaryForm, 0);
        while (true)
        {
            try
            {
                for (int i = 0; i < Count; i++)
                {
                    QualifiedAce qualifiedAce = _acl[i] as QualifiedAce;
                    if (qualifiedAce == null || (qualifiedAce.AceFlags & AceFlags.Inherited) != 0 || qualifiedAce.AceQualifier != qualifier || qualifiedAce.SecurityIdentifier != sid)
                    {
                        continue;
                    }
                    if (IsDS)
                    {
                        accessMask = num;
                        bool flag3 = !GetAccessMaskForRemoval(qualifiedAce, objectFlags, objectType, ref accessMask);
                        if ((qualifiedAce.AccessMask & accessMask) == 0)
                        {
                            continue;
                        }
                        flags = aceFlags;
                        bool flag4 = !GetInheritanceFlagsForRemoval(qualifiedAce, objectFlags, inheritedObjectType, ref flags);
                        if (((qualifiedAce.AceFlags & AceFlags.ContainerInherit) == 0 && (flags & AceFlags.ContainerInherit) != 0 && (flags & AceFlags.InheritOnly) != 0) || ((flags & AceFlags.ContainerInherit) == 0 && (qualifiedAce.AceFlags & AceFlags.ContainerInherit) != 0 && (qualifiedAce.AceFlags & AceFlags.InheritOnly) != 0) || ((aceFlags & AceFlags.ContainerInherit) != 0 && (aceFlags & AceFlags.InheritOnly) != 0 && (flags & AceFlags.ContainerInherit) == 0))
                        {
                            continue;
                        }
                        if (flag3 || flag4)
                        {
                            flag2 = false;
                            break;
                        }
                    }
                    else if ((qualifiedAce.AccessMask & accessMask) == 0)
                    {
                        continue;
                    }
                    if (saclSemantics && (qualifiedAce.AceFlags & flags & AceFlags.AuditFlags) == 0)
                    {
                        continue;
                    }
                    AceFlags aceFlags2 = AceFlags.None;
                    int num2 = 0;
                    ObjectAceFlags objectFlags2 = ObjectAceFlags.None;
                    Guid objectType2 = Guid.Empty;
                    Guid inheritedObjectType2 = Guid.Empty;
                    AceFlags aceFlags3 = AceFlags.None;
                    int accessMask2 = 0;
                    ObjectAceFlags objectFlags3 = ObjectAceFlags.None;
                    Guid objectType3 = Guid.Empty;
                    Guid inheritedObjectType3 = Guid.Empty;
                    AceFlags aceFlags4 = AceFlags.None;
                    int num3 = 0;
                    ObjectAceFlags objectFlags4 = ObjectAceFlags.None;
                    Guid objectType4 = Guid.Empty;
                    Guid inheritedObjectType4 = Guid.Empty;
                    AceFlags result = AceFlags.None;
                    bool total = false;
                    aceFlags2 = qualifiedAce.AceFlags;
                    num2 = qualifiedAce.AccessMask & ~accessMask;
                    if (qualifiedAce is ObjectAce originalAce)
                    {
                        GetObjectTypesForSplit(originalAce, num2, aceFlags2, out objectFlags2, out objectType2, out inheritedObjectType2);
                    }
                    if (saclSemantics)
                    {
                        aceFlags3 = qualifiedAce.AceFlags & (AceFlags)(~(uint)(flags & AceFlags.AuditFlags));
                        accessMask2 = qualifiedAce.AccessMask & accessMask;
                        if (qualifiedAce is ObjectAce originalAce2)
                        {
                            GetObjectTypesForSplit(originalAce2, accessMask2, aceFlags3, out objectFlags3, out objectType3, out inheritedObjectType3);
                        }
                    }
                    aceFlags4 = (qualifiedAce.AceFlags & AceFlags.InheritanceFlags) | (flags & qualifiedAce.AceFlags & AceFlags.AuditFlags);
                    num3 = qualifiedAce.AccessMask & accessMask;
                    if (!saclSemantics || (aceFlags4 & AceFlags.AuditFlags) != 0)
                    {
                        if (!RemoveInheritanceBits(aceFlags4, flags, IsDS, out result, out total))
                        {
                            flag2 = false;
                            break;
                        }
                        if (!total)
                        {
                            result |= aceFlags4 & AceFlags.AuditFlags;
                            if (qualifiedAce is ObjectAce originalAce3)
                            {
                                GetObjectTypesForSplit(originalAce3, num3, result, out objectFlags4, out objectType4, out inheritedObjectType4);
                            }
                        }
                    }
                    if (flag)
                    {
                        continue;
                    }
                    if (num2 != 0)
                    {
                        if (qualifiedAce is ObjectAce && (((ObjectAce)qualifiedAce).ObjectAceFlags & ObjectAceFlags.ObjectAceTypePresent) != 0 && (objectFlags2 & ObjectAceFlags.ObjectAceTypePresent) == 0)
                        {
                            _acl.RemoveAce(i);
                            ObjectAce ace = new ObjectAce(aceFlags2, qualifier, num2, qualifiedAce.SecurityIdentifier, objectFlags2, objectType2, inheritedObjectType2, isCallback: false, null);
                            _acl.InsertAce(i, ace);
                        }
                        else
                        {
                            qualifiedAce.AceFlags = aceFlags2;
                            qualifiedAce.AccessMask = num2;
                            if (qualifiedAce is ObjectAce objectAce)
                            {
                                objectAce.ObjectAceFlags = objectFlags2;
                                objectAce.ObjectAceType = objectType2;
                                objectAce.InheritedObjectAceType = inheritedObjectType2;
                            }
                        }
                    }
                    else
                    {
                        _acl.RemoveAce(i);
                        i--;
                    }
                    if (saclSemantics && (aceFlags3 & AceFlags.AuditFlags) != 0)
                    {
                        QualifiedAce ace2 = ((!(qualifiedAce is CommonAce)) ? ((QualifiedAce)new ObjectAce(aceFlags3, qualifier, accessMask2, qualifiedAce.SecurityIdentifier, objectFlags3, objectType3, inheritedObjectType3, isCallback: false, null)) : ((QualifiedAce)new CommonAce(aceFlags3, qualifier, accessMask2, qualifiedAce.SecurityIdentifier, isCallback: false, null)));
                        i++;
                        _acl.InsertAce(i, ace2);
                    }
                    if (!total)
                    {
                        QualifiedAce ace2 = ((!(qualifiedAce is CommonAce)) ? ((QualifiedAce)new ObjectAce(result, qualifier, num3, qualifiedAce.SecurityIdentifier, objectFlags4, objectType4, inheritedObjectType4, isCallback: false, null)) : ((QualifiedAce)new CommonAce(result, qualifier, num3, qualifiedAce.SecurityIdentifier, isCallback: false, null)));
                        i++;
                        _acl.InsertAce(i, ace2);
                    }
                }
            }
            catch (OverflowException)
            {
                _acl.SetBinaryForm(binaryForm, 0);
                return false;
            }
            if (!(flag && flag2))
            {
                break;
            }
            flag = false;
        }
        OnAclModificationTried();
        return flag2;
    }

References System.Security.AccessControl.CommonAcl._acl, System.Security.AccessControl.KnownAce.AccessMask, System.Security.AccessControl.GenericAce.AceFlags, System.Security.AccessControl.QualifiedAce.AceQualifier, System.SR.Arg_EnumAtLeastOneFlag, System.SR.Argument_ArgumentZero, System.Security.AccessControl.CommonAcl.BinaryLength, System.Security.AccessControl.CommonAcl.Count, System.Guid.Empty, System.Security.AccessControl.CommonAcl.GetAccessMaskForRemoval(), System.Security.AccessControl.CommonAcl.GetBinaryForm(), System.Security.AccessControl.CommonAcl.GetInheritanceFlagsForRemoval(), System.Security.AccessControl.CommonAcl.GetObjectTypesForSplit(), System.Security.AccessControl.RawAcl.InsertAce(), System.Security.AccessControl.CommonAcl.IsDS, System.Security.AccessControl.CommonAcl.OnAclModificationTried(), System.Security.AccessControl.RawAcl.RemoveAce(), System.Security.AccessControl.CommonAcl.RemoveInheritanceBits(), System.Security.AccessControl.KnownAce.SecurityIdentifier, System.Security.AccessControl.RawAcl.SetBinaryForm(), and System.Security.AccessControl.CommonAcl.ThrowIfNotCanonical().

Referenced by System.Security.AccessControl.DiscretionaryAcl.RemoveAccess(), System.Security.AccessControl.DiscretionaryAcl.RemoveAccess(), System.Security.AccessControl.SystemAcl.RemoveAudit(), and System.Security.AccessControl.SystemAcl.RemoveAudit().