private bool defaultImplies(ProtectionDomain domain, Permission permission)
{
if (domain == null && permission == null)
{
throw new java.lang.NullPointerException();
}
bool implies = false;
if (domain != null)
{
PermissionCollection total = getPermissions(domain);
PermissionCollection inherent = domain.getPermissions();
if (inherent != null)
{
java.util.Enumeration <Permission> en = inherent.elements();
while (en.hasMoreElements())
{
total.add(en.nextElement());
}
}
try {
implies = total.implies(permission);
} catch (java.lang.NullPointerException) {
// return false instead of throwing the NullPointerException
implies = false;
}
}
return(implies);
}
/**
* Returns a {@code PermissionCollection} describing what permissions are
* allowed for the specified {@code ProtectionDomain} (more specifically,
* its {@code CodeSource}) based on the current security policy.
* <p />
* Note that this method is not called for classes which are in the
* system domain (i.e. system classes). System classes are always
* given full permissions (i.e. AllPermission). This can not be changed by
* installing a new policy.
*
* @param domain
* the {@code ProtectionDomain} to compute the permissions for.
* @return the permissions that are granted to the specified {@code
* CodeSource}.
*/
public PermissionCollection getPermissions(ProtectionDomain domain)
{
Permissions permissions = new Permissions();
if (domain != null)
{
try {
PermissionCollection cds = getPermissions(domain
.getCodeSource());
if (cds != Policy.UNSUPPORTED_EMPTY_COLLECTION)
{
java.util.Enumeration <Permission> elements = cds.elements();
while (elements.hasMoreElements())
{
permissions.add(elements.nextElement());
}
}
} catch (java.lang.NullPointerException) {
// ignore the exception, just add nothing to the result set
}
PermissionCollection pds = domain.getPermissions();
if (pds != null)
{
java.util.Enumeration <Permission> pdElements = pds.elements();
while (pdElements.hasMoreElements())
{
permissions.add(pdElements.nextElement());
}
}
}
return(permissions);
}
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);
}
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;
}
}
/*
* 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);
}
/**
* 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;
}
