/// <summary> /// Check and see if this set of permissions implies the permissions /// expressed in "permission". /// </summary> /// <param name="permission"> the Permission object to compare /// </param> /// <returns> true if "permission" is a proper subset of a permission in /// the set, false if not. </returns> public override bool Implies(Permission permission) { if (!(permission is FilePermission)) { return(false); } FilePermission fp = (FilePermission)permission; int desired = fp.Mask; int effective = 0; int needed = desired; lock (this) { int len = Perms.Count; for (int i = 0; i < len; i++) { FilePermission x = (FilePermission)Perms[i]; if (((needed & x.Mask) != 0) && x.ImpliesIgnoreMask(fp)) { effective |= x.Mask; if ((effective & desired) == desired) { return(true); } needed = (desired ^ effective); } } } return(false); }
/// <summary> /// Checks if this FilePermission object "implies" the specified permission. /// <P> /// More specifically, this method returns true if: /// <ul> /// <li> <i>p</i> is an instanceof FilePermission, /// <li> <i>p</i>'s actions are a proper subset of this /// object's actions, and /// <li> <i>p</i>'s pathname is implied by this object's /// pathname. For example, "/tmp/*" implies "/tmp/foo", since /// "/tmp/*" encompasses all files in the "/tmp" directory, /// including the one named "foo". /// </ul> /// </summary> /// <param name="p"> the permission to check against. /// </param> /// <returns> <code>true</code> if the specified permission is not /// <code>null</code> and is implied by this object, /// <code>false</code> otherwise. </returns> public override bool Implies(Permission p) { if (!(p is FilePermission)) { return(false); } FilePermission that = (FilePermission)p; // we get the effective mask. i.e., the "and" of this and that. // They must be equal to that.mask for implies to return true. return(((this.Mask_Renamed & that.Mask_Renamed) == that.Mask_Renamed) && ImpliesIgnoreMask(that)); }
/// <summary> /// Checks two FilePermission objects for equality. Checks that <i>obj</i> is /// a FilePermission, and has the same pathname and actions as this object. /// </summary> /// <param name="obj"> the object we are testing for equality with this object. </param> /// <returns> <code>true</code> if obj is a FilePermission, and has the same /// pathname and actions as this FilePermission object, /// <code>false</code> otherwise. </returns> public override bool Equals(Object obj) { if (obj == this) { return(true); } if (!(obj is FilePermission)) { return(false); } FilePermission that = (FilePermission)obj; return((this.Mask_Renamed == that.Mask_Renamed) && this.Cpath.Equals(that.Cpath) && (this.Directory == that.Directory) && (this.Recursive == that.Recursive)); }
/// <summary> /// Checks if the Permission's actions are a proper subset of the /// this object's actions. Returns the effective mask iff the /// this FilePermission's path also implies that FilePermission's path. /// </summary> /// <param name="that"> the FilePermission to check against. </param> /// <returns> the effective mask </returns> internal bool ImpliesIgnoreMask(FilePermission that) { if (this.Directory) { if (this.Recursive) { // make sure that.path is longer then path so // something like /foo/- does not imply /foo if (that.Directory) { return((that.Cpath.Length() >= this.Cpath.Length()) && that.Cpath.StartsWith(this.Cpath)); } else { return((that.Cpath.Length() > this.Cpath.Length()) && that.Cpath.StartsWith(this.Cpath)); } } else { if (that.Directory) { // if the permission passed in is a directory // specification, make sure that a non-recursive // permission (i.e., this object) can't imply a recursive // permission. if (that.Recursive) { return(false); } else { return(this.Cpath.Equals(that.Cpath)); } } else { int last = that.Cpath.LastIndexOf(System.IO.Path.DirectorySeparatorChar); if (last == -1) { return(false); } else { // this.cpath.equals(that.cpath.substring(0, last+1)); // Use regionMatches to avoid creating new string return((this.Cpath.Length() == (last + 1)) && this.Cpath.RegionMatches(0, that.Cpath, 0, last + 1)); } } } } else if (that.Directory) { // if this is NOT recursive/wildcarded, // do not let it imply a recursive/wildcarded permission return(false); } else { return(this.Cpath.Equals(that.Cpath)); } }
public PrivilegedActionAnonymousInnerClassHelper(FilePermission outerInstance) { this.OuterInstance = outerInstance; }