public override bool implies(Permission permission)
{
if (permission == null)
{
// RI compatible
throw new java.lang.NullPointerException("Null permission"); //$NON-NLS-1$
}
if (allEnabled)
{
return(true);
}
java.lang.Class klass = permission.getClass();
PermissionCollection klassMates = null;
UnresolvedPermissionCollection billets = (UnresolvedPermissionCollection)klasses
.get(typeof(UnresolvedPermission).getClass());
if (billets != null && billets.hasUnresolved(permission))
{
// try to fill up klassMates with freshly resolved permissions
lock (klasses) {
klassMates = (PermissionCollection)klasses.get(klass);
try {
klassMates = billets.resolveCollection(permission,
klassMates);
} catch (java.lang.Exception ignore) {
//TODO log warning
ignore.printStackTrace();
}
if (klassMates != null)
{
//maybe klassMates were just created
// so put them into common map
klasses.put(klass, klassMates);
// very uncommon case, but not improbable one
if (klass == typeof(AllPermission).getClass())
{
allEnabled = true;
}
}
}
}
else
{
klassMates = (PermissionCollection)klasses.get(klass);
}
if (klassMates != null)
{
return(klassMates.implies(permission));
}
return(false);
}
/*
* Resolves all permissions of the same class as the specified target
* permission and adds them to the specified collection. If passed
* collection is {@code null} and some unresolved permissions were resolved,
* an appropriate new collection is instantiated and used. All resolved
* permissions are removed from this unresolved collection, and collection
* with resolved ones is returned.
*
* @param target
* a kind of permissions to be resolved.
* @param holder
* an existing collection for storing resolved permissions.
* @return a collection containing resolved permissions (if any found)
*/
internal PermissionCollection resolveCollection(Permission target,
PermissionCollection holder)
{
String klass = target.getClass().getName();
if (klasses.containsKey(klass))
{
lock (klasses)
{
java.util.Collection <Object> klassMates = (java.util.Collection <Object>)klasses.get(klass);
for (java.util.Iterator <Object> iter = klassMates.iterator(); iter.hasNext();)
{
UnresolvedPermission element = (UnresolvedPermission)iter
.next();
Permission resolved = element.resolve(target.getClass());
if (resolved != null)
{
if (holder == null)
{
holder = target.newPermissionCollection();
if (holder == null)
{
holder = new PermissionsHash();
}
}
holder.add(resolved);
iter.remove();
}
}
if (klassMates.size() == 0)
{
klasses.remove(klass);
}
}
}
return(holder);
}
/**
* Indicates whether the specified permission is implied by this permission.
*
* @param permission
* the permission to check against this permission.
* @return {@code true} if the specified permission is implied by this
* permission, {@code false} otherwise.
*/
public override bool implies(Permission permission)
{
if (permission != null && permission.getClass() == this.getClass())
{
String name = getName();
String thatName = permission.getName();
if (this is java.lang.RuntimePermission)
{
if (thatName.equals("exitVM"))
{
thatName = "exitVM.*";
}
if (name.equals("exitVM"))
{
name = "exitVM.*";
}
}
return(nameImplies(name, thatName));
}
return(false);
}
/**
* Adds a permission to the collection. The first added permission must be a
* subclass of BasicPermission, next permissions must be of the same class
* as the first one.
*
* @see java.security.PermissionCollection#add(java.security.Permission)
*/
public override void add(Permission permission)
{
if (isReadOnly())
{
throw new java.lang.SecurityException("collection is read-only"); //$NON-NLS-1$
}
if (permission == null)
{
throw new java.lang.IllegalArgumentException("invalid null permission"); //$NON-NLS-1$
}
java.lang.Class inClass = permission.getClass();
if (permClass != null)
{
if (permClass != inClass)
{
throw new java.lang.IllegalArgumentException("invalid permission: " + permission);
}
}
else if (!(permission is BasicPermission))
{
throw new java.lang.IllegalArgumentException("invalid permission: " + permission);
}
else
{
// this is the first element provided that another thread did not add
lock (this) {
if (permClass != null && inClass != permClass)
{
throw new java.lang.IllegalArgumentException("invalid permission: " + permission);
}
permClass = inClass;
}
}
String name = permission.getName();
items.put(name, permission);
allEnabled = allEnabled || (name.length() == 1 && '*' == name.charAt(0));
}
private bool allEnabled; // = false;
/**
* Adds the given {@code Permission} to this heterogeneous {@code
* PermissionCollection}. The {@code permission} is stored in its
* appropriate {@code PermissionCollection}.
*
* @param permission
* the {@code Permission} to be added.
* @throws SecurityException
* if this collection's {@link #isReadOnly()} method returns
* {@code true}.
* @throws NullPointerException
* if {@code permission} is {@code null}.
*/
public override void add(Permission permission)
{
if (isReadOnly())
{
throw new java.lang.SecurityException("collection is read-only"); //$NON-NLS-1$
}
if (permission == null)
{
throw new java.lang.NullPointerException("invalid null permission"); //$NON-NLS-1$
}
java.lang.Class klass = permission.getClass();
PermissionCollection klassMates = (PermissionCollection)klasses
.get(klass);
if (klassMates == null)
{
lock (klasses) {
klassMates = (PermissionCollection)klasses.get(klass);
if (klassMates == null)
{
klassMates = permission.newPermissionCollection();
if (klassMates == null)
{
klassMates = new PermissionsHash();
}
klasses.put(klass, klassMates);
}
}
}
klassMates.add(permission);
if (klass == typeof(AllPermission).getClass())
{
allEnabled = true;
}
}
/*
* Adds an unresolved permission to this {@code
* UnresolvedPermissionCollection}.
*
* @param permission
* the permission to be added.
* @throws SecurityException
* if this collection is read only.
* @throws IllegalArgumentException
* if {@code permission} is {@code null} or not an {@code
* UnresolvedPermission}.
*/
public override void add(Permission permission)
{
if (isReadOnly())
{
throw new java.lang.SecurityException("collection is read-only"); //$NON-NLS-1$
}
if (permission == null ||
permission.getClass() != typeof(UnresolvedPermission).getClass())
{
throw new java.lang.IllegalArgumentException("invalid permission: " + permission);
}
lock (klasses)
{
String klass = permission.getName();
java.util.Collection <Permission> klassMates = (java.util.Collection <Permission>)klasses.get(klass);
if (klassMates == null)
{
klassMates = new java.util.HashSet <Permission>();
klasses.put(klass, klassMates);
}
klassMates.add(permission);
}
}
/**
* Indicates whether the argument permission is implied by the receiver.
*
* @return boolean {@code true} if the argument permission is implied by the
* receiver, and {@code false} if it is not.
* @param permission
* the permission to check.
* @see Permission
*/
public override bool implies(Permission permission)
{
if (permission == null || permission.getClass() != permClass)
{
return(false);
}
if (allEnabled)
{
return(true);
}
String checkName = permission.getName();
//first check direct coincidence
if (items.containsKey(checkName))
{
return(true);
}
//Special treat with RuntimePermission exitVM.*
if (items.containsKey("exitVM") || items.containsKey("exitVM.*"))
{
if (checkName.endsWith("exitVM"))
{
return(true);
}
if (checkName.startsWith("exitVM.") && checkName.length() > "exitVM.".length())
{
return(true);
}
}
//now check if there are suitable wildcards
//suppose we have "a.b.c", let's check "a.b.*" and "a.*"
char[] name = checkName.toCharArray();
//I presume that "a.b.*" does not imply "a.b."
//so the dot at end is ignored
int pos = name.Length - 2;
for (; pos >= 0; pos--)
{
if (name[pos] == '.')
{
break;
}
}
while (pos >= 0)
{
name[pos + 1] = '*';
if (items.containsKey(new String(name, 0, pos + 2)))
{
return(true);
}
for (--pos; pos >= 0; pos--)
{
if (name[pos] == '.')
{
break;
}
}
}
return(false);
}
/*
* Returns true if this collection contains unresolved permissions
* with the same classname as argument permission.
*/
internal bool hasUnresolved(Permission permission)
{
return(klasses.containsKey(permission.getClass().getName()));
}
