libjava/classpath/java/security/UnresolvedPermission.java

   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