0N/A

0N/Apackage javax.management;

0N/A

0N/Aimport java.io.IOException;

0N/Aimport java.io.ObjectInputStream;

0N/Aimport java.security.BasicPermission;

0N/Aimport java.security.Permission;

0N/Aimport java.security.PermissionCollection;

0N/Aimport java.util.Collections;

0N/Aimport java.util.Enumeration;

0N/Aimport java.util.Set;

0N/Aimport java.util.StringTokenizer;

0N/A

0N/Apublic class MBeanServerPermission extends BasicPermission {

0N/A private static final long serialVersionUID = -5661980843569388590L;

0N/A

0N/A private final static int

0N/A CREATE = 0,

0N/A FIND = 1,

0N/A NEW = 2,

0N/A RELEASE = 3,

0N/A N_NAMES = 4;

0N/A

0N/A private final static String[] names = {

0N/A "createMBeanServer",

0N/A "findMBeanServer",

0N/A "newMBeanServer",

0N/A "releaseMBeanServer",

0N/A };

0N/A

0N/A private final static int

0N/A CREATE_MASK = 1<<CREATE,

0N/A FIND_MASK = 1<<FIND,

0N/A NEW_MASK = 1<<NEW,

0N/A RELEASE_MASK = 1<<RELEASE,

0N/A ALL_MASK = CREATE_MASK|FIND_MASK|NEW_MASK|RELEASE_MASK;

0N/A

0N/A /*

0N/A private final static String[] canonicalNames = new String[1 << N_NAMES];

0N/A

0N/A /*

0N/A transient int mask;

0N/A

0N/A /** <p>Create a new MBeanServerPermission with the given name.</p>

0N/A public MBeanServerPermission(String name) {

0N/A this(name, null);

0N/A }

0N/A

0N/A /** <p>Create a new MBeanServerPermission with the given name.</p>

0N/A public MBeanServerPermission(String name, String actions) {

0N/A super(getCanonicalName(parseMask(name)), actions);

0N/A

0N/A /* It's annoying to have to parse the name twice, but since

0N/A mask = parseMask(name);

0N/A

0N/A /* Check that actions is a null empty string */

0N/A if (actions != null && actions.length() > 0)

0N/A throw new IllegalArgumentException("MBeanServerPermission " +

0N/A "actions must be null: " +

0N/A actions);

0N/A }

MBeanServerPermission(int mask) {

super(getCanonicalName(mask));

this.mask = impliedMask(mask);

}

private void readObject(ObjectInputStream in)

throws IOException, ClassNotFoundException {

in.defaultReadObject();

mask = parseMask(getName());

}

static int simplifyMask(int mask) {

if ((mask & CREATE_MASK) != 0)

mask &= ~NEW_MASK;

return mask;

}

static int impliedMask(int mask) {

if ((mask & CREATE_MASK) != 0)

mask |= NEW_MASK;

return mask;

}

static String getCanonicalName(int mask) {

if (mask == ALL_MASK)

return "*";

mask = simplifyMask(mask);

synchronized (canonicalNames) {

if (canonicalNames[mask] == null)

canonicalNames[mask] = makeCanonicalName(mask);

}

return canonicalNames[mask];

}

private static String makeCanonicalName(int mask) {

final StringBuilder buf = new StringBuilder();

for (int i = 0; i < N_NAMES; i++) {

if ((mask & (1<<i)) != 0) {

if (buf.length() > 0)

buf.append(',');

buf.append(names[i]);

}

}

return buf.toString().intern();

/* intern() avoids duplication when the mask has only

}

/* Convert the string into a bitmask, including bits that

private static int parseMask(String name) {

/* Check that target name is a non-null non-empty string */

if (name == null) {

throw new NullPointerException("MBeanServerPermission: " +

"target name can't be null");

}

name = name.trim();

if (name.equals("*"))

return ALL_MASK;

/* If the name is empty, nameIndex will barf. */

if (name.indexOf(',') < 0)

return impliedMask(1 << nameIndex(name.trim()));

int mask = 0;

StringTokenizer tok = new StringTokenizer(name, ",");

while (tok.hasMoreTokens()) {

String action = tok.nextToken();

int i = nameIndex(action.trim());

mask |= (1 << i);

}

return impliedMask(mask);

}

private static int nameIndex(String name)

throws IllegalArgumentException {

for (int i = 0; i < N_NAMES; i++) {

if (names[i].equals(name))

return i;

}

final String msg =

"Invalid MBeanServerPermission name: \"" + name + "\"";

throw new IllegalArgumentException(msg);

}

public int hashCode() {

return mask;

}

/**

public boolean implies(Permission p) {

if (!(p instanceof MBeanServerPermission))

return false;

MBeanServerPermission that = (MBeanServerPermission) p;

return ((this.mask & that.mask) == that.mask);

}

/**

public boolean equals(Object obj) {

if (obj == this)

return true;

if (! (obj instanceof MBeanServerPermission))

return false;

MBeanServerPermission that = (MBeanServerPermission) obj;

return (this.mask == that.mask);

}

public PermissionCollection newPermissionCollection() {

return new MBeanServerPermissionCollection();

}

}

class MBeanServerPermissionCollection extends PermissionCollection {

/** @serial Null if no permissions in collection, otherwise a

private MBeanServerPermission collectionPermission;

private static final long serialVersionUID = -5661980843569388590L;

public synchronized void add(Permission permission) {

if (!(permission instanceof MBeanServerPermission)) {

final String msg =

"Permission not an MBeanServerPermission: " + permission;

throw new IllegalArgumentException(msg);

}

if (isReadOnly())

throw new SecurityException("Read-only permission collection");

MBeanServerPermission mbsp = (MBeanServerPermission) permission;

if (collectionPermission == null)

collectionPermission = mbsp;

else if (!collectionPermission.implies(permission)) {

int newmask = collectionPermission.mask | mbsp.mask;

collectionPermission = new MBeanServerPermission(newmask);

}

}

public synchronized boolean implies(Permission permission) {

return (collectionPermission != null &&

collectionPermission.implies(permission));

}

public synchronized Enumeration<Permission> elements() {

Set<Permission> set;

if (collectionPermission == null)

set = Collections.emptySet();

else

set = Collections.singleton((Permission) collectionPermission);

return Collections.enumeration(set);

}

}