/// <summary> /// Creates and returns a permission that is the intersection /// of the current permission and the specified permission. /// </summary> /// <param name="target">A permission to intersect with the current permission. /// It must be of the same type as the current permission.</param> /// <returns>A new permission that represents the intersection of the current permission /// and the specified permission. This new permission is null if the intersectionis empty.</returns> public override System.Security.IPermission Intersect(System.Security.IPermission target) { // If 'target' is null, return null. if (target == null) { return(null); } // Both objects must be the same type. FileAccessPermission filePerm = VerifyTypeMatch(target); // If 'this' and 'target' are unrestricted, return a new unrestricted permission. if (_specifiedAsUnrestricted && filePerm._specifiedAsUnrestricted) { return(Clone(true, PermissionType.Unrestricted)); } // Calculate the intersected permissions. If there are none, return null. PermissionType val = (PermissionType)Math.Min((Int32)_permission, (Int32)filePerm._permission); if (val == 0) { return(null); } // Get the intersect. val = new PermissionSource(_permission).Intersect(filePerm._permission); // Return a new object with the intersected permission value. return(Clone(false, val)); }
public override System.Security.IPermission Union(System.Security.IPermission target) { MemberAccessPermission result = (MemberAccessPermission)Copy(); result.items.AddRange(((MemberAccessPermission)target).CloneItems()); return(result); }
/// <summary> /// Verify the type. /// </summary> /// <param name="target">The current target.</param> /// <returns>The file access permission is a match; else throw exception.</returns> private FileAccessPermission VerifyTypeMatch(System.Security.IPermission target) { if (GetType() != target.GetType()) { throw new ArgumentException(String.Format("target must be of the {0} type", GetType().FullName)); } return((FileAccessPermission)target); }
public System.Security.IPermission Intersect(System.Security.IPermission target) { Report("{0}.Intersect(...)", this.GetType().FullName); if (target == null) { return null; } VerifyTargetType(target); GisaPrincipalPermission GisaTargetPermission = (GisaPrincipalPermission)target; GisaPrincipalPermission Result = new GisaPrincipalPermission(mPrincipal, null); ArrayList All = new ArrayList(); if (this.mClassName != null && GisaTargetPermission.mClassName != null && this.mClassName.Equals(GisaTargetPermission.mClassName)) { Result.mClassName = (string)(this.mClassName.Clone()); } else { return null; } if (this.mOperations != null && GisaTargetPermission.mOperations != null) { foreach (string op in this.mOperations) { if (System.Array.IndexOf(GisaTargetPermission.mOperations, op) >= GisaTargetPermission.mOperations.GetLowerBound(0)) { All.Add(op); } } } if (All.Count == 0) { return null; } else { Result.mOperations = new string[All.Count - 1]; All.CopyTo(Result.mOperations); return Result; //Nitro: TODO: INSTANT C# TODO TASK: The following 'ReDim' could not be resolved. A possible reason may be that the object of the ReDim was not declared as an array. /* ReDim Result.mOperations(All.Count - 1); All.CopyTo(Result.mOperations); return Result; */ } }
public override System.Security.IPermission CreatePermission() { System.Security.IPermission result = null; foreach (string perm in neededPermissions) { var p = new ApplicationDefinedPermission(PermissionState.Unrestricted) { Name = perm }; result = (result == null ? p : result.Intersect(p)); } return(result); }
/// <summary> /// If the two operations allow the exact set of operations /// </summary> public bool IsSubsetOf(System.Security.IPermission target) { if (target == null) { return(!this.m_isUnrestricted); } else { var permission = target as PolicyPermission; return(permission.m_isUnrestricted == this.m_isUnrestricted && this.m_policyId.StartsWith(permission.m_policyId)); } }
public System.Security.IPermission Union(System.Security.IPermission target) { Report("{0}.Union(...)", this.GetType().FullName); if (target == null) { return new GisaPrincipalPermission(mPrincipal, mClassName, this.mOperations); } else { VerifyTargetType(target); GisaPrincipalPermission GisaTargetPermission = (GisaPrincipalPermission)target; GisaPrincipalPermission Result = new GisaPrincipalPermission(mPrincipal, null); ArrayList All = new ArrayList(); if (this.mClassName != null && GisaTargetPermission.mClassName != null && this.mClassName.Equals(GisaTargetPermission.mClassName)) { Result.mClassName = (string)(this.mClassName.Clone()); } else { Result.mClassName = null; } if (this.mOperations != null) { All.AddRange(this.mOperations); } if (GisaTargetPermission.mOperations != null) { foreach (string s in GisaTargetPermission.mOperations) { if (! (All.Contains(s))) { All.Add(s); } } } //Nitro: TODO: INSTANT C# TODO TASK: The following 'ReDim' could not be resolved. A possible reason may be that the object of the ReDim was not declared as an array. Result.mOperations = new string[All.Count - 1]; All.CopyTo(Result.mOperations); return Result; } }
public override bool IsSubsetOf(System.Security.IPermission target) { var p = target as ApplicationDefinedPermission; if (p == null || p.Name == null || Name == null) { return(false); } return (this.Name.Length > p.Name.Length && this.Name.Substring(0, p.Name.Length) == p.Name && this.name[p.name.Length] == '.'); }
/// <summary> /// Determines whether the current permission /// is a subset of the specified permission. /// </summary> /// <param name="target">A permission that is to be tested for the subset relationship. /// This permission must be of the same type as the current permission.</param> /// <returns>True if the current permission is a subset of the specified permission; otherwise, false.</returns> public override bool IsSubsetOf(System.Security.IPermission target) { // If 'target' is null and this permission allows nothing, return true. if (target == null) { return(_permission == 0); } // Both objects must be the same type. FileAccessPermission filePerm = VerifyTypeMatch(target); // Return true if the permissions of 'this' is a subset of 'target'. return(new PermissionSource(_permission).IsSubsetOf(filePerm._permission)); }
/// <summary> /// Intersect the permission /// </summary> public System.Security.IPermission Intersect(System.Security.IPermission target) { if (target == null) { return(null); } if ((target as IUnrestrictedPermission)?.IsUnrestricted() == false) { return(target); } else { return(this.Copy()); } }
public override bool IsSubsetOf(System.Security.IPermission target) { if (base.IsSubsetOf(target)) { foreach (MemberAccessPermissionItem targetItem in ((MemberAccessPermission)target).items) { if (targetItem.ObjectType == ObjectType && targetItem.MemberName == MemberName && targetItem.Operation == Operation) { return(targetItem.Modifier == Modifier); } } return(true); } return(false); }
private void VerifyTargetType(System.Security.IPermission target) { if (target == null || target is GisaPrincipalPermission) { return; } string targetTypeFullName = "unknown"; try { targetTypeFullName = ((object)target).GetType().FullName; } catch (InvalidCastException) { targetTypeFullName = "unknown"; } throw new ArgumentException(string.Format("The type of target is {0} and should be {1}", targetTypeFullName, this.GetType().FullName), "target"); }
/// <summary> /// Creates a permission that is the union of the current permission and the specified permission. /// </summary> /// <param name="target">A permission to combine with the current permission. It must be of the same /// type as the current permission.</param> /// <returns>A new permission that represents the union of the current permission and /// the specified permission.</returns> public override System.Security.IPermission Union(System.Security.IPermission target) { // If 'target' is null, then return a copy of 'this'. if (target == null) { return(Copy()); } // Both objects must be the same type. FileAccessPermission filePerm = VerifyTypeMatch(target); // If 'this' or 'target' are unrestricted, return a new unrestricted permission. if (_specifiedAsUnrestricted || filePerm._specifiedAsUnrestricted) { return(Clone(true, PermissionType.Unrestricted)); } // Return a new object with the calculated, unioned permission value. return(Clone(false, new PermissionSource(_permission).Union(filePerm._permission))); }
public bool IsSubsetOf(System.Security.IPermission target) { Report("{0}.IsSubsetOf(...)", this.GetType().FullName); //FIXME: mClassName missing if (target == null) { return this.mOperations == null; } VerifyTargetType(target); if (! (this == target)) { GisaPrincipalPermission GisaTargetPermission = (GisaPrincipalPermission)target; if (this.mOperations != null) { if (GisaTargetPermission.mOperations != null) { foreach (string s in this.mOperations) { if (System.Array.IndexOf(((GisaPrincipalPermission)target).mOperations, s) < ((GisaPrincipalPermission)target).mOperations.GetLowerBound(0)) { return false; } } } } else { return GisaTargetPermission.mOperations == null; } } return true; }
public IPermission Union(IPermission target) { throw new NotImplementedException(); }
public bool IsSubsetOf(IPermission target) { throw new NotImplementedException(); }
public IPermission Intersect(IPermission target) { throw new NotImplementedException(); }
public override System.Security.IPermission Intersect(System.Security.IPermission target) { throw new NotImplementedException(); }
public override IPermission Intersect(System.Security.IPermission target) { return(null); }
public System.Security.IPermission Union(System.Security.IPermission target) { throw new NotImplementedException(); }