libjava/java/security/UnresolvedPermission.java

   1 /* UnresolvedPermission.java -- Placeholder for unresolved permissions
   2    Copyright (C) 1998, 2001, 2002 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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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 package java.security;
  39
  40 import java.io.Serializable;
  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.Hashtable;
  46 import java.util.Vector;
  47 import java.util.Enumeration;
  48 import java.util.NoSuchElementException;
  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   /**
 220    * Hashtable where we store permissions.
 221    *
 222    * @serial map of typename to a Vector of permissions (you'd think Sun
 223    *         would document this better!)
 224    */
 225   private final Hashtable permissions = new Hashtable();
 226
 227   /**
 228    * Add a permission.
 229    *
 230    * @param perm the permission to add
 231    * @throws IllegalArgumentException if perm is not an UnresolvedPermission
 232    * @throws SecurityException if the collection is read-only
 233    */
 234   public void add(Permission perm)
 235   {
 236     if (isReadOnly())
 237       throw new SecurityException();
 238     if (! (perm instanceof UnresolvedPermission))
 239       throw new IllegalArgumentException();
 240     UnresolvedPermission up = (UnresolvedPermission) perm;
 241     Vector v = (Vector) permissions.get(up.type);
 242     if (v == null)
 243       {
 244         v = new Vector();
 245         permissions.put(up.type, v);
 246       }
 247     v.add(up);
 248   }
 249
 250   /**
 251    * Returns true if perm is implied by the collection.
 252    *
 253    * @param perm the permission to check
 254    * @return false; unresolved permissions imply nothing
 255    */
 256   public boolean implies(Permission perm)
 257   {
 258     return false;
 259   }
 260
 261   /**
 262    * Return the elements.
 263    *
 264    * @return the elements
 265    */
 266   public Enumeration elements()
 267   {
 268     return new Enumeration()
 269     {
 270       Enumeration main_enum = permissions.elements();
 271       Enumeration sub_enum;
 272
 273       public boolean hasMoreElements()
 274       {
 275         if (sub_enum == null)
 276           {
 277             if (main_enum == null)
 278               return false;
 279             if (! main_enum.hasMoreElements())
 280               {
 281                 main_enum = null;
 282                 return false;
 283               }
 284             Vector v = (Vector) main_enum.nextElement();
 285             sub_enum = v.elements();
 286           }
 287         if (! sub_enum.hasMoreElements())
 288           {
 289             sub_enum = null;
 290             return hasMoreElements();
 291           }
 292         return true;
 293       }
 294
 295       public Object nextElement()
 296       {
 297         if (! hasMoreElements())
 298           throw new NoSuchElementException();
 299         return sub_enum.nextElement();
 300       }
 301     };
 302   }
 303 } // class UnresolvedPermissionCollection