/// <summary> /// Gets the PermissionCollection in this Permissions object for /// permissions whose type is the same as that of <i>p</i>. /// For example, if <i>p</i> is a FilePermission, /// the FilePermissionCollection /// stored in this Permissions object will be returned. /// /// If createEmpty is true, /// this method creates a new PermissionCollection object for the specified /// type of permission objects if one does not yet exist. /// To do so, it first calls the {@code newPermissionCollection} method /// on <i>p</i>. Subclasses of class Permission /// override that method if they need to store their permissions in a /// particular PermissionCollection object in order to provide the /// correct semantics when the {@code PermissionCollection.implies} /// method is called. /// If the call returns a PermissionCollection, that collection is stored /// in this Permissions object. If the call returns null and createEmpty /// is true, then /// this method instantiates and stores a default PermissionCollection /// that uses a hashtable to store its permission objects. /// /// createEmpty is ignored when creating empty PermissionCollection /// for unresolved permissions because of the overhead of determining the /// PermissionCollection to use. /// /// createEmpty should be set to false when this method is invoked from /// implies() because it incurs the additional overhead of creating and /// adding an empty PermissionCollection that will just return false. /// It should be set to true when invoked from add(). /// </summary> private PermissionCollection GetPermissionCollection(Permission p, bool createEmpty) { Class c = p.GetType(); PermissionCollection pc = PermsMap[c]; if (!HasUnresolved && !createEmpty) { return(pc); } else if (pc == null) { // Check for unresolved permissions pc = (HasUnresolved ? GetUnresolvedPermissions(p) : null); // if still null, create a new collection if (pc == null && createEmpty) { pc = p.NewPermissionCollection(); // still no PermissionCollection? // We'll give them a PermissionsHash. if (pc == null) { pc = new PermissionsHash(); } } if (pc != null) { PermsMap[c] = pc; } } return(pc); }
/// <summary> /// Resolves any unresolved permissions of type p. /// </summary> /// <param name="p"> the type of unresolved permission to resolve /// </param> /// <returns> PermissionCollection containing the unresolved permissions, /// or null if there were no unresolved permissions of type p. /// </returns> private PermissionCollection GetUnresolvedPermissions(Permission p) { // Called from within synchronized method so permsMap doesn't need lock UnresolvedPermissionCollection uc = (UnresolvedPermissionCollection)PermsMap[typeof(UnresolvedPermission)]; // we have no unresolved permissions if uc is null if (uc == null) { return(null); } IList <UnresolvedPermission> unresolvedPerms = uc.GetUnresolvedPermissions(p); // we have no unresolved permissions of this type if unresolvedPerms is null if (unresolvedPerms == null) { return(null); } java.security.cert.Certificate[] certs = null; Object[] signers = p.GetType().Signers; int n = 0; if (signers != null) { for (int j = 0; j < signers.Length; j++) { if (signers[j] is java.security.cert.Certificate) { n++; } } certs = new java.security.cert.Certificate[n]; n = 0; for (int j = 0; j < signers.Length; j++) { if (signers[j] is java.security.cert.Certificate) { certs[n++] = (java.security.cert.Certificate)signers[j]; } } } PermissionCollection pc = null; lock (unresolvedPerms) { int len = unresolvedPerms.Count; for (int i = 0; i < len; i++) { UnresolvedPermission up = unresolvedPerms[i]; Permission perm = up.Resolve(p, certs); if (perm != null) { if (pc == null) { pc = p.NewPermissionCollection(); if (pc == null) { pc = new PermissionsHash(); } } pc.Add(perm); } } } return(pc); }