GNU Classpath (0.20) | |
Frames | No Frames |
1: /* UnresolvedPermission.java -- Placeholder for unresolved permissions 2: Copyright (C) 1998, 2001, 2002, 2004, 2005 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package java.security; 40: 41: // All uses of Certificate in this file refer to the one in the listed 42: // package, not this one. 43: import java.security.cert.Certificate; 44: import java.util.Arrays; 45: import java.util.Enumeration; 46: import java.util.Hashtable; 47: import java.util.NoSuchElementException; 48: import java.util.Vector; 49: 50: /** 51: * This class is used to hold instances of all permissions that cannot 52: * be resolved to available permission classes when the security 53: * <code>Policy</code> object is instantiated. This may happen when the 54: * necessary security class has not yet been downloaded from the network. 55: * 56: * <p>Instances of this class are re-resolved when 57: * <code>AccessController</code> check is done. At that time, a scan is 58: * made of all existing <code>UnresolvedPermission</code> objects and they 59: * are converted to objects of the appropriate permission type if the class 60: * for that type is then available. 61: * 62: * @author Aaron M. Renn (arenn@urbanophile.com) 63: * @see Permission 64: * @see Permissions 65: * @see PermissionCollection 66: * @see Policy 67: * @since 1.1 68: * @status updated to 1.4 69: */ 70: public final class UnresolvedPermission extends Permission 71: { 72: /** 73: * Compatible with JDK 1.1+. 74: */ 75: private static final long serialVersionUID = -4821973115467008846L; 76: 77: /** 78: * The list of actions associated with this permission object. 79: * 80: * @serial the permission actions 81: */ 82: private final String actions; 83: 84: /** 85: * The list of <code>Certificates</code> associated with this object. 86: */ 87: private final transient Certificate[] certs; 88: 89: /** 90: * The name of the class this object should be resolved to. 91: * 92: * @serial the fully-qualified classname of the resolved type 93: */ 94: // Package visible for use by UnresolvedPermissionCollection. 95: final String type; 96: 97: /** 98: * The name of the permission. 99: * 100: * @serial the permission name 101: */ 102: private final String name; 103: 104: /** 105: * Create a new instance with all the information necessary to resolve it 106: * to an instance of the proper class at a future time. 107: * 108: * @param type the fully-qualified name of the class of this permission 109: * @param name the name of this permission 110: * @param actions the action list for this permission 111: * @param certs the list of certificates that sign this permission 112: */ 113: public UnresolvedPermission(String type, String name, String actions, 114: Certificate[] certs) 115: { 116: super(name); 117: this.name = name; 118: this.type = type; 119: this.actions = actions; 120: this.certs = certs; 121: } 122: 123: /** 124: * This method returns <code>false</code> always to indicate that this 125: * permission does not imply the specified permission. An 126: * <code>UnresolvedPermission</code> never grants any permissions. 127: * 128: * @param perm the <code>Permission</code> object to test 129: * @return false; until a permission is resolved, it implies nothing 130: */ 131: public boolean implies(Permission perm) 132: { 133: return false; 134: } 135: 136: /** 137: * This method tests this permission for equality against the specified 138: * <code>Object</code>. This will be true if and only if the following 139: * conditions are met:<ul> 140: * <li>The specified <code>Object</code> is an UnresolvedPermission</li> 141: * <li>The specified permission has the same type (i.e., desired class name) 142: * as this permission.</li> 143: * <li>The specified permission has the same name as this one.</li> 144: * <li>The specified permissoin has the same action list as this one.</li> 145: * <li>The specified permission has the same certificate list as this 146: * one.</li> 147: * </ul> 148: * 149: * @param obj the <code>Object</code> to test for equality 150: * @return true if the specified object is equal to this one 151: */ 152: public boolean equals(Object obj) 153: { 154: if (! (obj instanceof UnresolvedPermission)) 155: return (false); 156: UnresolvedPermission up = (UnresolvedPermission) obj; 157: return up.name.equals(name) && up.actions.equals(actions) 158: && up.type.equals(type) && Arrays.equals(up.certs, certs); 159: } 160: 161: /** 162: * Returns a hash code value for this object. Following the lead of 163: * Permission, this returns the hashcode of the permission name. 164: * 165: * @return A hash value 166: */ 167: public int hashCode() 168: { 169: return name.hashCode(); 170: } 171: 172: /** 173: * This method returns the list of actions associated with this 174: * permission. 175: * 176: * @return the action list 177: */ 178: public String getActions() 179: { 180: return actions; 181: } 182: 183: /** 184: * This method returns a <code>String</code> representation of this 185: * class. The format is: '(unresolved "ClassName "name" "actions")' 186: * 187: * @return <code>String</code> representation of this object 188: */ 189: public String toString() 190: { 191: return "(unresolved " + type + ' ' + name + ' ' + actions + ')'; 192: } 193: 194: /** 195: * This class returns a <code>PermissionCollection</code> object that can 196: * be used to store instances of <code>UnresolvedPermission</code>. 197: * 198: * @return a new <code>PermissionCollection</code> 199: */ 200: public PermissionCollection newPermissionCollection() 201: { 202: return new UnresolvedPermissionCollection(); 203: } 204: } // class UnresolvedPermission 205: 206: /** 207: * Implements the permission collection for unresolved permissions, and 208: * obeys serialization of JDK. 209: * 210: * @author Eric Blake (ebb9@email.byu.edu) 211: */ 212: class UnresolvedPermissionCollection extends PermissionCollection 213: { 214: /** 215: * Compatible with JDK 1.1+. 216: */ 217: private static final long serialVersionUID = -7176153071733132400L; 218: 219: // Package-private to avoid a trampoline. 220: /** 221: * Hashtable where we store permissions. 222: * 223: * @serial map of typename to a Vector of permissions (you'd think Sun 224: * would document this better!) 225: */ 226: final Hashtable permissions = new Hashtable(); 227: 228: /** 229: * Add a permission. 230: * 231: * @param perm the permission to add 232: * @throws IllegalArgumentException if perm is not an UnresolvedPermission 233: * @throws SecurityException if the collection is read-only 234: */ 235: public void add(Permission perm) 236: { 237: if (isReadOnly()) 238: throw new SecurityException(); 239: if (! (perm instanceof UnresolvedPermission)) 240: throw new IllegalArgumentException(); 241: UnresolvedPermission up = (UnresolvedPermission) perm; 242: Vector v = (Vector) permissions.get(up.type); 243: if (v == null) 244: { 245: v = new Vector(); 246: permissions.put(up.type, v); 247: } 248: v.add(up); 249: } 250: 251: /** 252: * Returns true if perm is implied by the collection. 253: * 254: * @param perm the permission to check 255: * @return false; unresolved permissions imply nothing 256: */ 257: public boolean implies(Permission perm) 258: { 259: return false; 260: } 261: 262: /** 263: * Return the elements. 264: * 265: * @return the elements 266: */ 267: public Enumeration elements() 268: { 269: return new Enumeration() 270: { 271: Enumeration main_enum = permissions.elements(); 272: Enumeration sub_enum; 273: 274: public boolean hasMoreElements() 275: { 276: if (sub_enum == null) 277: { 278: if (main_enum == null) 279: return false; 280: if (! main_enum.hasMoreElements()) 281: { 282: main_enum = null; 283: return false; 284: } 285: Vector v = (Vector) main_enum.nextElement(); 286: sub_enum = v.elements(); 287: } 288: if (! sub_enum.hasMoreElements()) 289: { 290: sub_enum = null; 291: return hasMoreElements(); 292: } 293: return true; 294: } 295: 296: public Object nextElement() 297: { 298: if (! hasMoreElements()) 299: throw new NoSuchElementException(); 300: return sub_enum.nextElement(); 301: } 302: }; 303: } 304: } // class UnresolvedPermissionCollection
GNU Classpath (0.20) |