libjava/java/security/BasicPermission.java

   1 /* BasicPermission.java -- implements a simple named permission
   2    Copyright (C) 1998, 1999, 2002, 2003, 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., 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
  39 package java.security;
  40
  41 import java.io.Serializable;
  42 import java.util.Enumeration;
  43 import java.util.Hashtable;
  44
  45 /**
  46  * This class implements a simple model for named permissions without an
  47  * associated action list.  That is, either the named permission is granted
  48  * or it is not.
  49  *
  50  * <p>It also supports trailing wildcards to allow the easy granting of
  51  * permissions in a hierarchical fashion.  (For example, the name "org.gnu.*"
  52  * might grant all permissions under the "org.gnu" permissions hierarchy).
  53  * The only valid wildcard character is a '*' which matches anything. It
  54  * must be the rightmost element in the permission name and must follow a
  55  * '.' or else the Permission name must consist of only a '*'. Any other
  56  * occurrence of a '*' is not valid.
  57  *
  58  * <p>This class ignores the action list.  Subclasses can choose to implement
  59  * actions on top of this class if desired.
  60  *
  61  * @author Aaron M. Renn (arenn@urbanophile.com)
  62  * @author Eric Blake (ebb9@email.byu.edu)
  63  * @see Permission
  64  * @see Permissions
  65  * @see PermissionCollection
  66  * @see RuntimePermission
  67  * @see SecurityPermission
  68  * @see PropertyPermission
  69  * @see AWTPermission
  70  * @see NetPermission
  71  * @see SecurityManager
  72  * @since 1.1
  73  * @status updated to 1.4
  74  */
  75 public abstract class BasicPermission extends java.security.Permission
  76   implements Serializable
  77   // FIXME extends with fully qualified classname as workaround for gcj 3.3.
  78 {
  79   /**
  80    * Compatible with JDK 1.1+.
  81    */
  82   private static final long serialVersionUID = 6279438298436773498L;
  83
  84   /**
  85    * Create a new instance with the specified permission name. If the
  86    * name is empty an exception is thrown.
  87    *
  88    * @param name the name of this permission
  89    * @throws NullPointerException if name is null
  90    * @throws IllegalArgumentException if name is invalid
  91    */
  92   public BasicPermission(String name)
  93   {
  94     super(name);
  95
  96     // This routine used to check for illegal wildcards, but no such
  97     // requirement exists in the specification and Sun's runtime
  98     // doesn't appear to do it.
  99
 100     if ("".equals(name))
 101       throw new IllegalArgumentException("Empty name");
 102   }
 103
 104   /**
 105    * Create a new instance with the specified permission name. If the name
 106    * is empty, or contains an illegal wildcard character, an exception is
 107    * thrown. The actions parameter is ignored.
 108    *
 109    * @param name the name of this permission
 110    * @param actions ignored
 111    * @throws NullPointerException if name is null
 112    * @throws IllegalArgumentException if name is invalid
 113    */
 114   public BasicPermission(String name, String actions)
 115   {
 116     this(name);
 117   }
 118
 119   /**
 120    * This method tests to see if the specified permission is implied by this
 121    * permission.  This will be true if the following conditions are met:<ul>
 122    * <li>The specified object is an instance of the same class as this
 123    * object.</li>
 124    * <li>The name of the specified permission is implied by this permission's
 125    * name based on wildcard matching. For example, "a.*" implies "a.b".</li>
 126    * </ul>
 127    *
 128    * @param perm the <code>Permission</code> object to test against
 129    * @return true if the specified permission is implied
 130    */
 131   public boolean implies(Permission perm)
 132   {
 133     if (! getClass().isInstance(perm))
 134       return false;
 135
 136     String otherName = perm.getName();
 137     String name = getName();
 138
 139     if (name.equals(otherName))
 140       return true;
 141
 142     int last = name.length() - 1;
 143     return name.charAt(last) == '*'
 144       && otherName.startsWith(name.substring(0, last));
 145   }
 146
 147   /**
 148    * This method tests to see if this object is equal to the specified
 149    * <code>Object</code>.  This will be true if and only if the specified
 150    * object meets the following conditions:<ul>
 151    * <li>It is an instance of the same class as this.</li>
 152    * <li>It has the same name as this permission.</li>
 153    * </ul>
 154    *
 155    * @param obj the <code>Object</code> to test for equality
 156    * @return true if obj is semantically equal to this
 157    */
 158   public boolean equals(Object obj)
 159   {
 160     return getClass().isInstance(obj)
 161       && getName().equals(((BasicPermission) obj).getName());
 162   }
 163
 164   /**
 165    * This method returns a hash code for this permission object.  The hash
 166    * code returned is the value returned by calling the <code>hashCode</code>
 167    * method on the <code>String</code> that is the name of this permission.
 168    *
 169    * @return a hash value for this object
 170    */
 171   public int hashCode()
 172   {
 173     return getName().hashCode();
 174   }
 175
 176   /**
 177    * This method returns a list of the actions associated with this
 178    * permission.  This method always returns the empty string ("") since
 179    * this class ignores actions.
 180    *
 181    * @return the action list
 182    */
 183   public String getActions()
 184   {
 185     return "";
 186   }
 187
 188   /**
 189    * This method returns an instance of <code>PermissionCollection</code>
 190    * suitable for storing <code>BasicPermission</code> objects.  The
 191    * collection returned can only store objects of the same type as this.
 192    * Subclasses which use actions must override this method; but a class with
 193    * no actions will work fine with this.
 194    *
 195    * @return a new empty <code>PermissionCollection</code> object
 196    */
 197   public PermissionCollection newPermissionCollection()
 198   {
 199     return new BasicPermissionCollection(getClass());
 200   }
 201
 202   /**
 203    * Implements AllPermission.newPermissionCollection, and obeys serialization
 204    * of JDK.
 205    *
 206    * @author Eric Blake (ebb9@email.byu.edu)
 207    */
 208   private static final class BasicPermissionCollection extends PermissionCollection
 209   {
 210     /**
 211      * Compatible with JDK 1.1+.
 212      */
 213     private static final long serialVersionUID = 739301742472979399L;
 214
 215     /**
 216      * The permissions in the collection.
 217      *
 218      * @serial a hash mapping name to permissions, all of type permClass
 219      */
 220     private final Hashtable permissions = new Hashtable();
 221
 222     /**
 223      * If "*" is in the collection.
 224      *
 225      * @serial true if a permission named "*" is in the collection
 226      */
 227     private boolean all_allowed;
 228
 229     /**
 230      * The runtime class which all entries in the table must belong to.
 231      *
 232      * @serial the limiting subclass of this collection
 233      */
 234     private final Class permClass;
 235
 236     /**
 237      * Construct a collection over the given runtime class.
 238      *
 239      * @param c the class
 240      */
 241     BasicPermissionCollection(Class c)
 242     {
 243       permClass = c;
 244     }
 245
 246     /**
 247      * Add a Permission. It must be of the same type as the permission which
 248      * created this collection.
 249      *
 250      * @param perm the permission to add
 251      * @throws IllegalArgumentException if perm is not the correct type
 252      * @throws SecurityException if the collection is read-only
 253      */
 254     public void add(Permission perm)
 255     {
 256       if (isReadOnly())
 257         throw new SecurityException("readonly");
 258       if (! permClass.isInstance(perm))
 259         throw new IllegalArgumentException("Expecting instance of " + permClass);
 260       BasicPermission bp = (BasicPermission) perm;
 261       String name = bp.getName();
 262       if (name.equals("*"))
 263         all_allowed = true;
 264       permissions.put(name, bp);
 265     }
 266
 267     /**
 268      * Returns true if this collection implies the given permission.
 269      *
 270      * @param permission the permission to check
 271      * @return true if it is implied by this
 272      */
 273     public boolean implies(Permission permission)
 274     {
 275       if (! permClass.isInstance(permission))
 276         return false;
 277       if (all_allowed)
 278         return true;
 279       BasicPermission toImply = (BasicPermission) permission;
 280       String name = toImply.getName();
 281       if (name.equals("*"))
 282         return false;
 283       int prefixLength = name.length();
 284       if (name.endsWith("*"))
 285         prefixLength -= 2;
 286
 287       while (true)
 288         {
 289           if (permissions.get(name) != null)
 290             return true;
 291           prefixLength = name.lastIndexOf('.', prefixLength);
 292           if (prefixLength < 0)
 293             return false;
 294           name = name.substring(0, prefixLength + 1) + '*';
 295         }
 296     }
 297
 298     /**
 299      * Enumerate over the collection.
 300      *
 301      * @return an enumeration of the collection contents
 302      */
 303     public Enumeration elements()
 304     {
 305       return permissions.elements();
 306     }
 307   } // class BasicPermissionCollection
 308 } // class BasicPermission