This ProtectionDomain class encapsulates the characteristics
* of a domain, which encloses a set of classes whose instances are granted a
* set of permissions when being executed on behalf of a given set of
* Principals.
*
*
A static set of permissions can be bound to a ProtectionDomain
* when it is constructed; such permissions are granted to the domain regardless
* of the {@link Policy} in force. However, to support dynamic security
* policies, a ProtectionDomain can also be constructed such that
* it is dynamically mapped to a set of permissions by the current {@link
* Policy} whenever a permission is checked.
CodeSource for this protection domain. */
private CodeSource code_source;
/** This is the set of permissions granted to this domain. */
private PermissionCollection perms;
/** The {@link ClassLoader} associated with this domain. */
private ClassLoader classloader;
/** The array of Principals associated with this domain.. */
private Principal[] principals;
/** Post 1.4 the policy may be refreshed! use false for pre 1.4. */
private boolean staticBinding;
/**
* Creates a new ProtectionDomain with the given {@link
* CodeSource} and {@link Permissions}. If the permissions object is not
* null, then setReadOnly() will be called on the
* passed in {@link Permissions} object. The only permissions granted to this
* domain are the ones specified; the current {@link Policy} will not be
* consulted.
*
* @param codesource the codesource associated with this domain.
* @param permissions the permissions granted to this domain
*/
public ProtectionDomain(CodeSource codesource, PermissionCollection permissions)
{
this(codesource, permissions, null, null, false);
}
/**
* Creates a new ProtectionDomain qualified by the given CodeSource,
* Permissions, ClassLoader and array of Principals. If the permissions
* object is not null, then setReadOnly() will be called on the
* passed in Permissions object. The permissions granted to this domain are
* dynamic; they include both the static permissions passed to this
* constructor, and any permissions granted to this domain by the current
* Policy at the time a permission is checked.
This constructor is typically used by {@link ClassLoader}s and {@link
* DomainCombiner}s which delegate to Policy to actively
* associate the permissions granted to this domain. This constructor affords
* the Policy provider the opportunity to augment the supplied
* PermissionCollection to reflect policy changes.
null.
* @since 1.2
*/
public final CodeSource getCodeSource()
{
return code_source;
}
/**
* Returns the {@link ClassLoader} of this domain.
*
* @return the {@link ClassLoader} of this domain which may be
* null.
* @since 1.4
*/
public final ClassLoader getClassLoader()
{
return this.classloader;
}
/**
* Returns an array of principals for this domain.
*
* @return returns a non-null array of principals for this domain. Changes to
* this array will have no impact on the ProtectionDomain.
* @since 1.4
*/
public final Principal[] getPrincipals()
{
return (Principal[]) principals.clone();
}
/**
* Returns the static permissions granted to this domain.
*
* @return the static set of permissions for this domain which may be
* null.
* @see Policy#refresh()
* @see Policy#getPermissions(ProtectionDomain)
*/
public final PermissionCollection getPermissions()
{
return perms;
}
/**
* Check and see if this ProtectionDomain implies the
* permissions expressed in the Permission object.
The set of permissions evaluated is a function of whether the
* ProtectionDomain was constructed with a static set of
* permissions or it was bound to a dynamically mapped set of permissions.
If the ProtectionDomain was constructed to a statically
* bound {@link PermissionCollection} then the permission will only be checked
* against the {@link PermissionCollection} supplied at construction.
However, if the ProtectionDomain was constructed with the
* constructor variant which supports dynamically binding permissions, then
* the permission will be checked against the combination of the
* {@link PermissionCollection} supplied at construction and the current
* {@link Policy} binding.
*
* @param permission the {@link Permission} object to check.
* @return true if permission is implicit to this
* ProtectionDomain.
*/
public boolean implies(Permission permission)
{
if (staticBinding)
return (perms == null ? false : perms.implies(permission));
// Else dynamically bound. Do we have it?
// NOTE: this will force loading of Policy.currentPolicy
return Policy.getCurrentPolicy().implies(this, permission);
}
/**
* Convert a ProtectionDomain to a String.
*
* @return a string representation of the object.
*/
public String toString()
{
String linesep = System.getProperty("line.separator");
StringBuffer sb = new StringBuffer("ProtectionDomain (").append(linesep);
if (code_source == null)
sb.append("CodeSource:null");
else
sb.append(code_source);
sb.append(linesep);
if (classloader == null)
sb.append("ClassLoader:null");
else
sb.append(classloader);
sb.append(linesep);
sb.append("Principals:");
if (principals != null && principals.length > 0)
{
sb.append("[");
Principal pal;
for (int i = 0; i < principals.length; i++)
{
pal = principals[i];
sb.append("'").append(pal.getName())
.append("' of type ").append(pal.getClass().getName());
if (i < principals.length-1)
sb.append(", ");
}
sb.append("]");
}
else
sb.append("none");
sb.append(linesep);
if (!staticBinding) // include all but dont force loading Policy.currentPolicy
if (Policy.isLoaded())
sb.append(Policy.getCurrentPolicy().getPermissions(this));
else // fallback on this one's permissions
sb.append(perms);
else
sb.append(perms);
return sb.append(linesep).append(")").append(linesep).toString();
}
}