Source for java.security.UnresolvedPermission

   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: 
 205:   /**
 206:    * Return the name of the class of the unresolved permission.
 207:    * @since 1.5
 208:    */
 209:   public String getUnresolvedType()
 210:   {
 211:     return type;
 212:   }
 213: 
 214:   /**
 215:    * Return the name of the unresolved permission.
 216:    * @since 1.5
 217:    */
 218:   public String getUnresolvedName()
 219:   {
 220:     return name;
 221:   }
 222: 
 223:   /**
 224:    * Return the actions of the unresolved permission, or null
 225:    * if there are no actions.
 226:    * @since 1.5
 227:    */
 228:   public String getUnresolvedActions()
 229:   {
 230:     return actions;
 231:   }
 232: 
 233:   /**
 234:    * Return the certificates of the unresolved permission.
 235:    * If there are no certificates, null is returned.  Otherwise,
 236:    * a new array is returned.
 237:    * @since 1.5
 238:    */
 239:   public Certificate[] getUnresolvedCerts()
 240:   {
 241:     if (certs == null)
 242:       return null;
 243:     return (Certificate[]) certs.clone();
 244:   }
 245: } // class UnresolvedPermission
 246: 
 247: /**
 248:  * Implements the permission collection for unresolved permissions, and
 249:  * obeys serialization of JDK.
 250:  *
 251:  * @author Eric Blake (ebb9@email.byu.edu)
 252:  */
 253: class UnresolvedPermissionCollection extends PermissionCollection
 254: {
 255:   /**
 256:    * Compatible with JDK 1.1+.
 257:    */
 258:   private static final long serialVersionUID = -7176153071733132400L;
 259: 
 260:   // Package-private to avoid a trampoline.
 261:   /**
 262:    * Hashtable where we store permissions.
 263:    *
 264:    * @serial map of typename to a Vector of permissions (you'd think Sun
 265:    *         would document this better!)
 266:    */
 267:   final Hashtable permissions = new Hashtable();
 268: 
 269:   /**
 270:    * Add a permission.
 271:    *
 272:    * @param perm the permission to add
 273:    * @throws IllegalArgumentException if perm is not an UnresolvedPermission
 274:    * @throws SecurityException if the collection is read-only
 275:    */
 276:   public void add(Permission perm)
 277:   {
 278:     if (isReadOnly())
 279:       throw new SecurityException();
 280:     if (! (perm instanceof UnresolvedPermission))
 281:       throw new IllegalArgumentException();
 282:     UnresolvedPermission up = (UnresolvedPermission) perm;
 283:     Vector v = (Vector) permissions.get(up.type);
 284:     if (v == null)
 285:       {
 286:         v = new Vector();
 287:         permissions.put(up.type, v);
 288:       }
 289:     v.add(up);
 290:   }
 291: 
 292:   /**
 293:    * Returns true if perm is implied by the collection.
 294:    *
 295:    * @param perm the permission to check
 296:    * @return false; unresolved permissions imply nothing
 297:    */
 298:   public boolean implies(Permission perm)
 299:   {
 300:     return false;
 301:   }
 302: 
 303:   /**
 304:    * Return the elements.
 305:    *
 306:    * @return the elements
 307:    */
 308:   public Enumeration elements()
 309:   {
 310:     return new Enumeration()
 311:     {
 312:       Enumeration main_enum = permissions.elements();
 313:       Enumeration sub_enum;
 314: 
 315:       public boolean hasMoreElements()
 316:       {
 317:         if (sub_enum == null)
 318:           {
 319:             if (main_enum == null)
 320:               return false;
 321:             if (! main_enum.hasMoreElements())
 322:               {
 323:                 main_enum = null;
 324:                 return false;
 325:               }
 326:             Vector v = (Vector) main_enum.nextElement();
 327:             sub_enum = v.elements();
 328:           }
 329:         if (! sub_enum.hasMoreElements())
 330:           {
 331:             sub_enum = null;
 332:             return hasMoreElements();
 333:           }
 334:         return true;
 335:       }
 336: 
 337:       public Object nextElement()
 338:       {
 339:         if (! hasMoreElements())
 340:           throw new NoSuchElementException();
 341:         return sub_enum.nextElement();
 342:       }
 343:     };
 344:   }
 345: } // class UnresolvedPermissionCollection