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: } // 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