Source for java.security.BasicPermission

   1: /* BasicPermission.java -- implements a simple named permission
   2:    Copyright (C) 1998, 1999, 2002, 2003, 2004, 2005, 2006
   3:    Free Software Foundation, Inc.
   4: 
   5: This file is part of GNU Classpath.
   6: 
   7: GNU Classpath is free software; you can redistribute it and/or modify
   8: it under the terms of the GNU General Public License as published by
   9: the Free Software Foundation; either version 2, or (at your option)
  10: any later version.
  11: 
  12: GNU Classpath is distributed in the hope that it will be useful, but
  13: WITHOUT ANY WARRANTY; without even the implied warranty of
  14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15: General Public License for more details.
  16: 
  17: You should have received a copy of the GNU General Public License
  18: along with GNU Classpath; see the file COPYING.  If not, write to the
  19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20: 02110-1301 USA.
  21: 
  22: Linking this library statically or dynamically with other modules is
  23: making a combined work based on this library.  Thus, the terms and
  24: conditions of the GNU General Public License cover the whole
  25: combination.
  26: 
  27: As a special exception, the copyright holders of this library give you
  28: permission to link this library with independent modules to produce an
  29: executable, regardless of the license terms of these independent
  30: modules, and to copy and distribute the resulting executable under
  31: terms of your choice, provided that you also meet, for each linked
  32: independent module, the terms and conditions of the license of that
  33: module.  An independent module is a module which is not derived from
  34: or based on this library.  If you modify this library, you may extend
  35: this exception to your version of the library, but you are not
  36: obligated to do so.  If you do not wish to do so, delete this
  37: exception statement from your version. */
  38: 
  39: 
  40: package java.security;
  41: 
  42: import java.io.Serializable;
  43: import java.util.Enumeration;
  44: import java.util.Hashtable;
  45: 
  46: /**
  47:  * This class implements a simple model for named permissions without an
  48:  * associated action list.  That is, either the named permission is granted
  49:  * or it is not.
  50:  *
  51:  * <p>It also supports trailing wildcards to allow the easy granting of
  52:  * permissions in a hierarchical fashion.  (For example, the name "org.gnu.*"
  53:  * might grant all permissions under the "org.gnu" permissions hierarchy).
  54:  * The only valid wildcard character is a '*' which matches anything. It
  55:  * must be the rightmost element in the permission name and must follow a
  56:  * '.' or else the Permission name must consist of only a '*'. Any other
  57:  * occurrence of a '*' is not valid.
  58:  *
  59:  * <p>This class ignores the action list.  Subclasses can choose to implement
  60:  * actions on top of this class if desired.
  61:  *
  62:  * @author Aaron M. Renn (arenn@urbanophile.com)
  63:  * @author Eric Blake (ebb9@email.byu.edu)
  64:  * @see Permission
  65:  * @see Permissions
  66:  * @see PermissionCollection
  67:  * @see RuntimePermission
  68:  * @see SecurityPermission
  69:  * @see PropertyPermission
  70:  * @see AWTPermission
  71:  * @see NetPermission
  72:  * @see SecurityManager
  73:  * @since 1.1
  74:  * @status updated to 1.4
  75:  */
  76: public abstract class BasicPermission extends Permission
  77:   implements Serializable
  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 (name.equals(""))
 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