* * * Identifier * *Suffix * Identifier* * QualifiedIdentifier.* * QualifiedIdentifier.Identifier * QualifiedIdentifier.*Suffix * QualifiedIdentifier.Identifier* ** where QualifiedIdentifier and Identifier are as defined in * The Java(TM) Language Specification except that whitespace is not * permitted, and Suffix is defined to be one or more characters * that may be part of an Identifier. These forms are defined to * match fully qualified names of the form * QualifiedIdentifier.Identifier as follows: *
| Target Name | *QualifiedIdentifier Match | *Identifier Match | *
|---|---|---|
| * | *any | *any | *
| method | *any | *method | *
| *suffix | *any | *any ending with suffix | *
| prefix* | *any | *any starting with prefix | *
| type.* | *type | *any | *
| type.method | *type | *method | *
| type.*suffix | *type | *any ending with suffix | *
| type.prefix* | *type | *any starting with prefix | *
* This class, and simple subclasses of it, can be used (for example) with
* {@link net.jini.jeri.BasicInvocationDispatcher}. It is
* recommended that a simple subclass of this class be defined for each
* remote object implementation class that can be exported using an
* {@link net.jini.export.Exporter}, to allow separation of
* grants in policy files.
*
*
* @since 2.0
*/
public class AccessPermission extends Permission {
private static final long serialVersionUID = 7269818741475881138L;
/**
* The interface name, or null if wildcarded.
*/
private transient String iface;
/**
* The name of the method, with prefix or suffix '*' permitted,
* or null if wildcarded.
*/
private transient String method;
/**
* Creates an instance with the specified target name.
*
* @param name the target name
* @throws NullPointerException if the target name is null
* @throws IllegalArgumentException if the target name does not match
* the syntax specified in the comments at the beginning of this class
*/
public AccessPermission(String name) {
super(name);
init(name);
}
/**
* Parses the target name and initializes the transient fields.
*/
private void init(String name) {
if (name == null) {
throw new NullPointerException("name cannot be null");
} else if (name.length() == 0) {
throw new IllegalArgumentException("name cannot be empty");
}
int i = name.lastIndexOf('.');
if (i >= 0) {
iface = name.substring(0, i);
name = name.substring(i + 1);
}
if (!name.equals("*")) {
method = name;
}
if (iface != null && !validClass(iface)) {
throw new IllegalArgumentException("invalid interface name");
} else if (method != null && !validMethod(method)) {
throw new IllegalArgumentException("invalid method name");
}
}
/**
* Returns true if the name is a syntactically valid fully qualified
* class name (no whitespace permitted), and returns false otherwise.
*/
private static boolean validClass(String name) {
int len = name.length();
outer:
for (int i = 0;
i < len && Character.isJavaIdentifierStart(name.charAt(i));
i++)
{
while (++i < len) {
char c = name.charAt(i);
if (c == '.') {
continue outer;
}
if (!Character.isJavaIdentifierPart(c)) {
return false;
}
}
return true;
}
return false;
}
/**
* Returns true if the name is a syntactically valid method name, or
* if the name is a syntactically valid method name with a '*' appended
* or could be constructed from some syntactically valid method name
* containing more than two characters by replacing the first character
* of that name with '*', and returns false otherwise.
*/
private static boolean validMethod(String name) {
int len = name.length();
if (len == 0) {
return false;
}
char c = name.charAt(0);
if (!Character.isJavaIdentifierStart(c) && !(c == '*' && len > 1)) {
return false;
}
if (c != '*' && name.charAt(len - 1) == '*') {
len--;
}
while (--len >= 1) {
if (!Character.isJavaIdentifierPart(name.charAt(len))) {
return false;
}
}
return true;
}
/**
* Returns true if every fully qualified name that
* matches the specified permission's name also matches this
* permission's name; returns false otherwise.
*
* @param perm the permission to check
* @return true if every fully qualified name that
* matches the specified permission's name also matches this
* permission's name; false otherwise
*/
public boolean implies(Permission perm) {
if (perm == null || perm.getClass() != getClass()) {
return false;
}
AccessPermission ap = (AccessPermission) perm;
if (iface != null && !iface.equals(ap.iface)) {
return false;
} else if (method == null) {
return true;
} else if (ap.method == null) {
return false;
}
int len = method.length() - 1;
if (method.charAt(0) == '*') {
return ap.method.regionMatches(ap.method.length() - len,
method, 1, len);
} else if (method.charAt(len) == '*') {
return ap.method.regionMatches(0, method, 0, len);
}
return method.equals(ap.method);
}
/**
* Returns true if the specified object is an instance
* of the same class as this permission and has the same target name
* as this permission; returns false otherwise.
*/
public boolean equals(Object obj) {
if (obj == this) {
return true;
} else if (obj == null || obj.getClass() != getClass()) {
return false;
}
return getName().equals(((Permission) obj).getName());
}
/**
* Returns a hash code value for this object.
*/
public int hashCode() {
return getName().hashCode();
}
/**
* Returns the empty string.
*/
public String getActions() {
return "";
}
/**
* Verifies the syntax of the target name and recreates any transient
* state.
*
* @throws InvalidObjectException if the target name is null,
* or if the target name does not match the syntax specified in the
* comments at the beginning of this class
*/
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException
{
s.defaultReadObject();
Exception cause;
try {
init(getName());
return;
} catch (NullPointerException e) {
cause = e;
} catch (IllegalArgumentException e) {
cause = e;
}
InvalidObjectException e =
new InvalidObjectException(cause.getMessage());
e.initCause(cause);
throw e;
}
}