SecurityException if the
* action is forbidden.
*
* A typical check is as follows, just before the dangerous operation:
*
* SecurityManager sm = System.getSecurityManager(); * if (sm != null) * sm.checkABC(argument, ...); ** Note that this is thread-safe, by caching the security manager in a local * variable rather than risking a NullPointerException if the mangager is * changed between the check for null and before the permission check. * *
The special method checkPermission is a catchall, and
* the default implementation calls
* AccessController.checkPermission. In fact, all the other
* methods default to calling checkPermission.
*
*
Sometimes, the security check needs to happen from a different context,
* such as when called from a worker thread. In such cases, use
* getSecurityContext to take a snapshot that can be passed
* to the worker thread:
*
* Object context = null; * SecurityManager sm = System.getSecurityManager(); * if (sm != null) * context = sm.getSecurityContext(); // defaults to an AccessControlContext * // now, in worker thread * if (sm != null) * sm.checkPermission(permission, context); ** *
Permissions fall into these categories: File, Socket, Net, Security,
* Runtime, Property, AWT, Reflect, and Serializable. Each of these
* permissions have a property naming convention, that follows a hierarchical
* naming convention, to make it easy to grant or deny several permissions
* at once. Some permissions also take a list of permitted actions, such
* as "read" or "write", to fine-tune control even more. The permission
* java.security.AllPermission grants all permissions.
*
*
The default methods in this class deny all things to all people. You
* must explicitly grant permission for anything you want to be legal when
* subclassing this class.
*
* @author John Keiser
* @author Eric Blake (ebb9@email.byu.edu)
* @see ClassLoader
* @see SecurityException
* @see #checkTopLevelWindow(Object)
* @see System#getSecurityManager()
* @see System#setSecurityManager(SecurityManager)
* @see AccessController
* @see AccessControlContext
* @see AccessControlException
* @see Permission
* @see BasicPermission
* @see java.io.FilePermission
* @see java.net.SocketPermission
* @see java.util.PropertyPermission
* @see RuntimePermission
* @see java.awt.AWTPermission
* @see Policy
* @see SecurityPermission
* @see ProtectionDomain
* @since 1.0
* @status still missing 1.4 functionality
*/
public class SecurityManager
{
/**
* The current security manager. This is located here instead of in
* System, to avoid security problems, as well as bootstrap issues.
* Make sure to access it in a thread-safe manner; it is package visible
* to avoid overhead in java.lang.
*/
static volatile SecurityManager current;
/**
* Tells whether or not the SecurityManager is currently performing a
* security check.
* @deprecated Use {@link #checkPermission(Permission)} instead.
*/
protected boolean inCheck;
/**
* Construct a new security manager. There may be a security check, of
* RuntimePermission("createSecurityManager").
*
* @throws SecurityException if permission is denied
*/
public SecurityManager()
{
/* "When there is security manager installed, the security manager
need to check the package access. However, if the security
manager itself uses any unloaded class, it will trigger the
classloading, which causes infinite loop. There is no easy
legal solution. The workaround will be that security manager
can not depend on any unloaded class. In the constructor of
security manager, it must transitively load all classes it
refers to." Sun bug #4242924. */
// Load and initialize java.security.Security
java.security.Security.getProvider((String)null);
SecurityManager sm = System.getSecurityManager();
if (sm != null)
sm.checkPermission(new RuntimePermission("createSecurityManager"));
}
/**
* Tells whether or not the SecurityManager is currently performing a
* security check.
*
* @return true if the SecurityManager is in a security check
* @see #inCheck
* @deprecated use {@link #checkPermission(Permission)} instead
*/
public boolean getInCheck()
{
return inCheck;
}
/**
* Get a list of all the classes currently executing methods on the Java
* stack. getClassContext()[0] is the currently executing method (ie. the
* class that CALLED getClassContext, not SecurityManager).
*
* @return an array of classes on the Java execution stack
*/
protected Class[] getClassContext()
{
Class[] stack1 = VMStackWalker.getClassContext();
Class[] stack2 = new Class[stack1.length - 1];
System.arraycopy(stack1, 1, stack2, 0, stack1.length - 1);
return stack2;
}
/**
* Find the ClassLoader of the first non-system class on the execution
* stack. A non-system class is one whose ClassLoader is not equal to
* {@link ClassLoader#getSystemClassLoader()} or its ancestors. This
* will return null in three cases:
*
*
java.security.AllPermission succeeds.java.security.AllPermission succeeds.java.security.AllPermission succeeds.Currently the only methods that use this are checkRead() and
* checkConnect(). The default implementation returns an
* AccessControlContext.
*
* @return a security context
* @see #checkConnect(String, int, Object)
* @see #checkRead(String, Object)
* @see AccessControlContext
* @see AccessController#getContext()
*/
public Object getSecurityContext()
{
return AccessController.getContext();
}
/**
* Check if the current thread is allowed to perform an operation that
* requires the specified Permission. This defaults to
* AccessController.checkPermission.
*
* @param perm the Permission required
* @throws SecurityException if permission is denied
* @throws NullPointerException if perm is null
* @since 1.2
*/
public void checkPermission(Permission perm)
{
AccessController.checkPermission(perm);
}
/**
* Check if the current thread is allowed to perform an operation that
* requires the specified Permission. This is done in a
* context previously returned by getSecurityContext(). The
* default implementation expects context to be an AccessControlContext,
* and it calls AccessControlContext.checkPermission(perm).
*
* @param perm the Permission required
* @param context a security context
* @throws SecurityException if permission is denied, or if context is
* not an AccessControlContext
* @throws NullPointerException if perm is null
* @see #getSecurityContext()
* @see AccessControlContext#checkPermission(Permission)
* @since 1.2
*/
public void checkPermission(Permission perm, Object context)
{
if (! (context instanceof AccessControlContext))
throw new SecurityException("Missing context");
((AccessControlContext) context).checkPermission(perm);
}
/**
* Check if the current thread is allowed to create a ClassLoader. This
* method is called from ClassLoader.ClassLoader(), and checks
* RuntimePermission("createClassLoader"). If you override
* this, you should call super.checkCreateClassLoader() rather
* than throwing an exception.
*
* @throws SecurityException if permission is denied
* @see ClassLoader#ClassLoader()
*/
public void checkCreateClassLoader()
{
checkPermission(new RuntimePermission("createClassLoader"));
}
/**
* Check if the current thread is allowed to modify another Thread. This is
* called by Thread.stop(), suspend(), resume(), interrupt(), destroy(),
* setPriority(), setName(), and setDaemon(). The default implementation
* checks RuntimePermission("modifyThread") on system threads
* (ie. threads in ThreadGroup with a null parent), and returns silently on
* other threads.
*
*
If you override this, you must do two things. First, call
* super.checkAccess(t), to make sure you are not relaxing
* requirements. Second, if the calling thread has
* RuntimePermission("modifyThread"), return silently, so that
* core classes (the Classpath library!) can modify any thread.
*
* @param thread the other Thread to check
* @throws SecurityException if permission is denied
* @throws NullPointerException if thread is null
* @see Thread#stop()
* @see Thread#suspend()
* @see Thread#resume()
* @see Thread#setPriority(int)
* @see Thread#setName(String)
* @see Thread#setDaemon(boolean)
*/
public void checkAccess(Thread thread)
{
if (thread.getThreadGroup() != null
&& thread.getThreadGroup().parent == null)
checkPermission(new RuntimePermission("modifyThread"));
}
/**
* Check if the current thread is allowed to modify a ThreadGroup. This is
* called by Thread.Thread() (to add a thread to the ThreadGroup),
* ThreadGroup.ThreadGroup() (to add this ThreadGroup to a parent),
* ThreadGroup.stop(), suspend(), resume(), interrupt(), destroy(),
* setDaemon(), and setMaxPriority(). The default implementation
* checks RuntimePermission("modifyThread") on the system group
* (ie. the one with a null parent), and returns silently on other groups.
*
*
If you override this, you must do two things. First, call
* super.checkAccess(t), to make sure you are not relaxing
* requirements. Second, if the calling thread has
* RuntimePermission("modifyThreadGroup"), return silently,
* so that core classes (the Classpath library!) can modify any thread.
*
* @param g the ThreadGroup to check
* @throws SecurityException if permission is denied
* @throws NullPointerException if g is null
* @see Thread#Thread()
* @see ThreadGroup#ThreadGroup(String)
* @see ThreadGroup#stop()
* @see ThreadGroup#suspend()
* @see ThreadGroup#resume()
* @see ThreadGroup#interrupt()
* @see ThreadGroup#setDaemon(boolean)
* @see ThreadGroup#setMaxPriority(int)
*/
public void checkAccess(ThreadGroup g)
{
if (g.parent == null)
checkPermission(new RuntimePermission("modifyThreadGroup"));
}
/**
* Check if the current thread is allowed to exit the JVM with the given
* status. This method is called from Runtime.exit() and Runtime.halt().
* The default implementation checks
* RuntimePermission("exitVM"). If you override this, call
* super.checkExit rather than throwing an exception.
*
* @param status the status to exit with
* @throws SecurityException if permission is denied
* @see Runtime#exit(int)
* @see Runtime#halt(int)
*/
public void checkExit(int status)
{
checkPermission(new RuntimePermission("exitVM"));
}
/**
* Check if the current thread is allowed to execute the given program. This
* method is called from Runtime.exec(). If the name is an absolute path,
* the default implementation checks
* FilePermission(program, "execute"), otherwise it checks
* FilePermission("<<ALL FILES>>", "execute"). If
* you override this, call super.checkExec rather than
* throwing an exception.
*
* @param program the name of the program to exec
* @throws SecurityException if permission is denied
* @throws NullPointerException if program is null
* @see Runtime#exec(String[], String[], File)
*/
public void checkExec(String program)
{
if (! program.equals(new File(program).getAbsolutePath()))
program = "<RuntimePermission("loadLibrary." + filename). If you
* override this, call super.checkLink rather than throwing
* an exception.
*
* @param filename the full name of the library to load
* @throws SecurityException if permission is denied
* @throws NullPointerException if filename is null
* @see Runtime#load(String)
*/
public void checkLink(String filename)
{
// Use the toString() hack to do the null check.
checkPermission(new RuntimePermission("loadLibrary."
+ filename.toString()));
}
/**
* Check if the current thread is allowed to read the given file using the
* FileDescriptor. This method is called from
* FileInputStream.FileInputStream(). The default implementation checks
* RuntimePermission("readFileDescriptor"). If you override
* this, call super.checkRead rather than throwing an
* exception.
*
* @param desc the FileDescriptor representing the file to access
* @throws SecurityException if permission is denied
* @throws NullPointerException if desc is null
* @see FileInputStream#FileInputStream(FileDescriptor)
*/
public void checkRead(FileDescriptor desc)
{
if (desc == null)
throw new NullPointerException();
checkPermission(new RuntimePermission("readFileDescriptor"));
}
/**
* Check if the current thread is allowed to read the given file. This
* method is called from FileInputStream.FileInputStream(),
* RandomAccessFile.RandomAccessFile(), File.exists(), canRead(), isFile(),
* isDirectory(), lastModified(), length() and list(). The default
* implementation checks FilePermission(filename, "read"). If
* you override this, call super.checkRead rather than
* throwing an exception.
*
* @param filename the full name of the file to access
* @throws SecurityException if permission is denied
* @throws NullPointerException if filename is null
* @see File
* @see FileInputStream#FileInputStream(String)
* @see RandomAccessFile#RandomAccessFile(String, String)
*/
public void checkRead(String filename)
{
checkPermission(new FilePermission(filename, "read"));
}
/**
* Check if the current thread is allowed to read the given file. using the
* given security context. The context must be a result of a previous call
* to getSecurityContext(). The default implementation checks
* AccessControlContext.checkPermission(new FilePermission(filename,
* "read")). If you override this, call super.checkRead
* rather than throwing an exception.
*
* @param filename the full name of the file to access
* @param context the context to determine access for
* @throws SecurityException if permission is denied, or if context is
* not an AccessControlContext
* @throws NullPointerException if filename is null
* @see #getSecurityContext()
* @see AccessControlContext#checkPermission(Permission)
*/
public void checkRead(String filename, Object context)
{
if (! (context instanceof AccessControlContext))
throw new SecurityException("Missing context");
AccessControlContext ac = (AccessControlContext) context;
ac.checkPermission(new FilePermission(filename, "read"));
}
/**
* Check if the current thread is allowed to write the given file using the
* FileDescriptor. This method is called from
* FileOutputStream.FileOutputStream(). The default implementation checks
* RuntimePermission("writeFileDescriptor"). If you override
* this, call super.checkWrite rather than throwing an
* exception.
*
* @param desc the FileDescriptor representing the file to access
* @throws SecurityException if permission is denied
* @throws NullPointerException if desc is null
* @see FileOutputStream#FileOutputStream(FileDescriptor)
*/
public void checkWrite(FileDescriptor desc)
{
if (desc == null)
throw new NullPointerException();
checkPermission(new RuntimePermission("writeFileDescriptor"));
}
/**
* Check if the current thread is allowed to write the given file. This
* method is called from FileOutputStream.FileOutputStream(),
* RandomAccessFile.RandomAccessFile(), File.canWrite(), mkdir(), and
* renameTo(). The default implementation checks
* FilePermission(filename, "write"). If you override this,
* call super.checkWrite rather than throwing an exception.
*
* @param filename the full name of the file to access
* @throws SecurityException if permission is denied
* @throws NullPointerException if filename is null
* @see File
* @see File#canWrite()
* @see File#mkdir()
* @see File#renameTo(File)
* @see FileOutputStream#FileOutputStream(String)
* @see RandomAccessFile#RandomAccessFile(String, String)
*/
public void checkWrite(String filename)
{
checkPermission(new FilePermission(filename, "write"));
}
/**
* Check if the current thread is allowed to delete the given file. This
* method is called from File.delete(). The default implementation checks
* FilePermission(filename, "delete"). If you override this,
* call super.checkDelete rather than throwing an exception.
*
* @param filename the full name of the file to delete
* @throws SecurityException if permission is denied
* @throws NullPointerException if filename is null
* @see File#delete()
*/
public void checkDelete(String filename)
{
checkPermission(new FilePermission(filename, "delete"));
}
/**
* Check if the current thread is allowed to connect to a given host on a
* given port. This method is called from Socket.Socket(). A port number
* of -1 indicates the caller is attempting to determine an IP address, so
* the default implementation checks
* SocketPermission(host, "resolve"). Otherwise, the default
* implementation checks
* SocketPermission(host + ":" + port, "connect"). If you
* override this, call super.checkConnect rather than throwing
* an exception.
*
* @param host the host to connect to
* @param port the port to connect on
* @throws SecurityException if permission is denied
* @throws NullPointerException if host is null
* @see Socket#Socket()
*/
public void checkConnect(String host, int port)
{
if (port == -1)
checkPermission(new SocketPermission(host, "resolve"));
else
// Use the toString() hack to do the null check.
checkPermission(new SocketPermission(host.toString() + ":" + port,
"connect"));
}
/**
* Check if the current thread is allowed to connect to a given host on a
* given port, using the given security context. The context must be a
* result of a previous call to getSecurityContext. A port
* number of -1 indicates the caller is attempting to determine an IP
* address, so the default implementation checks
* AccessControlContext.checkPermission(new SocketPermission(host,
* "resolve")). Otherwise, the default implementation checks
* AccessControlContext.checkPermission(new SocketPermission(host
* + ":" + port, "connect")). If you override this, call
* super.checkConnect rather than throwing an exception.
*
* @param host the host to connect to
* @param port the port to connect on
* @param context the context to determine access for
*
* @throws SecurityException if permission is denied, or if context is
* not an AccessControlContext
* @throws NullPointerException if host is null
*
* @see #getSecurityContext()
* @see AccessControlContext#checkPermission(Permission)
*/
public void checkConnect(String host, int port, Object context)
{
if (! (context instanceof AccessControlContext))
throw new SecurityException("Missing context");
AccessControlContext ac = (AccessControlContext) context;
if (port == -1)
ac.checkPermission(new SocketPermission(host, "resolve"));
else
// Use the toString() hack to do the null check.
ac.checkPermission(new SocketPermission(host.toString() + ":" + port,
"connect"));
}
/**
* Check if the current thread is allowed to listen to a specific port for
* data. This method is called by ServerSocket.ServerSocket(). The default
* implementation checks
* SocketPermission("localhost:" + (port == 0 ? "1024-" : "" + port),
* "listen"). If you override this, call
* super.checkListen rather than throwing an exception.
*
* @param port the port to listen on
* @throws SecurityException if permission is denied
* @see ServerSocket#ServerSocket(int)
*/
public void checkListen(int port)
{
checkPermission(new SocketPermission("localhost:"
+ (port == 0 ? "1024-" : "" +port),
"listen"));
}
/**
* Check if the current thread is allowed to accept a connection from a
* particular host on a particular port. This method is called by
* ServerSocket.implAccept(). The default implementation checks
* SocketPermission(host + ":" + port, "accept"). If you
* override this, call super.checkAccept rather than throwing
* an exception.
*
* @param host the host which wishes to connect
* @param port the port the connection will be on
* @throws SecurityException if permission is denied
* @throws NullPointerException if host is null
* @see ServerSocket#accept()
*/
public void checkAccept(String host, int port)
{
// Use the toString() hack to do the null check.
checkPermission(new SocketPermission(host.toString() + ":" + port,
"accept"));
}
/**
* Check if the current thread is allowed to read and write multicast to
* a particular address. The default implementation checks
* SocketPermission(addr.getHostAddress(), "accept,connect").
* If you override this, call super.checkMulticast rather than
* throwing an exception.
*
* @param addr the address to multicast to
* @throws SecurityException if permission is denied
* @throws NullPointerException if host is null
* @since 1.1
*/
public void checkMulticast(InetAddress addr)
{
checkPermission(new SocketPermission(addr.getHostAddress(),
"accept,connect"));
}
/**
*Check if the current thread is allowed to read and write multicast to
* a particular address with a particular ttl (time-to-live) value. The
* default implementation ignores ttl, and checks
* SocketPermission(addr.getHostAddress(), "accept,connect").
* If you override this, call super.checkMulticast rather than
* throwing an exception.
*
* @param addr the address to multicast to
* @param ttl value in use for multicast send
* @throws SecurityException if permission is denied
* @throws NullPointerException if host is null
* @since 1.1
* @deprecated use {@link #checkPermission(Permission)} instead
*/
public void checkMulticast(InetAddress addr, byte ttl)
{
checkPermission(new SocketPermission(addr.getHostAddress(),
"accept,connect"));
}
/**
* Check if the current thread is allowed to read or write all the system
* properties at once. This method is called by System.getProperties()
* and setProperties(). The default implementation checks
* PropertyPermission("*", "read,write"). If you override
* this, call super.checkPropertiesAccess rather than
* throwing an exception.
*
* @throws SecurityException if permission is denied
* @see System#getProperties()
* @see System#setProperties(Properties)
*/
public void checkPropertiesAccess()
{
checkPermission(new PropertyPermission("*", "read,write"));
}
/**
* Check if the current thread is allowed to read a particular system
* property (writes are checked directly via checkPermission). This method
* is called by System.getProperty() and setProperty(). The default
* implementation checks PropertyPermission(key, "read"). If
* you override this, call super.checkPropertyAccess rather
* than throwing an exception.
*
* @param key the key of the property to check
*
* @throws SecurityException if permission is denied
* @throws NullPointerException if key is null
* @throws IllegalArgumentException if key is ""
*
* @see System#getProperty(String)
*/
public void checkPropertyAccess(String key)
{
checkPermission(new PropertyPermission(key, "read"));
}
/**
* Check if the current thread is allowed to create a top-level window. If
* it is not, the operation should still go through, but some sort of
* nonremovable warning should be placed on the window to show that it
* is untrusted. This method is called by Window.Window(). The default
* implementation checks
* AWTPermission("showWindowWithoutWarningBanner"), and returns
* true if no exception was thrown. If you override this, use
* return super.checkTopLevelWindow rather than returning
* false.
*
* @param window the window to create
* @return true if there is permission to show the window without warning
* @throws NullPointerException if window is null
* @see java.awt.Window#Window(java.awt.Frame)
*/
public boolean checkTopLevelWindow(Object window)
{
if (window == null)
throw new NullPointerException();
try
{
checkPermission(new AWTPermission("showWindowWithoutWarningBanner"));
return true;
}
catch (SecurityException e)
{
return false;
}
}
/**
* Check if the current thread is allowed to create a print job. This
* method is called by Toolkit.getPrintJob(). The default implementation
* checks RuntimePermission("queuePrintJob"). If you override
* this, call super.checkPrintJobAccess rather than throwing
* an exception.
*
* @throws SecurityException if permission is denied
* @see java.awt.Toolkit#getPrintJob(java.awt.Frame, String, Properties)
* @since 1.1
*/
public void checkPrintJobAccess()
{
checkPermission(new RuntimePermission("queuePrintJob"));
}
/**
* Check if the current thread is allowed to use the system clipboard. This
* method is called by Toolkit.getSystemClipboard(). The default
* implementation checks AWTPermission("accessClipboard"). If
* you override this, call super.checkSystemClipboardAccess
* rather than throwing an exception.
*
* @throws SecurityException if permission is denied
* @see java.awt.Toolkit#getSystemClipboard()
* @since 1.1
*/
public void checkSystemClipboardAccess()
{
checkPermission(new AWTPermission("accessClipboard"));
}
/**
* Check if the current thread is allowed to use the AWT event queue. This
* method is called by Toolkit.getSystemEventQueue(). The default
* implementation checks AWTPermission("accessEventQueue").
* you override this, call super.checkAwtEventQueueAccess
* rather than throwing an exception.
*
* @throws SecurityException if permission is denied
* @see java.awt.Toolkit#getSystemEventQueue()
* @since 1.1
*/
public void checkAwtEventQueueAccess()
{
checkPermission(new AWTPermission("accessEventQueue"));
}
/**
* Check if the current thread is allowed to access the specified package
* at all. This method is called by ClassLoader.loadClass() in user-created
* ClassLoaders. The default implementation gets a list of all restricted
* packages, via Security.getProperty("package.access"). Then,
* if packageName starts with or equals any restricted package, it checks
* RuntimePermission("accessClassInPackage." + packageName).
* If you override this, you should call
* super.checkPackageAccess before doing anything else.
*
* @param packageName the package name to check access to
* @throws SecurityException if permission is denied
* @throws NullPointerException if packageName is null
* @see ClassLoader#loadClass(String, boolean)
* @see Security#getProperty(String)
*/
public void checkPackageAccess(String packageName)
{
checkPackageList(packageName, "package.access", "accessClassInPackage.");
}
/**
* Check if the current thread is allowed to define a class into the
* specified package. This method is called by ClassLoader.loadClass() in
* user-created ClassLoaders. The default implementation gets a list of all
* restricted packages, via
* Security.getProperty("package.definition"). Then, if
* packageName starts with or equals any restricted package, it checks
* RuntimePermission("defineClassInPackage." + packageName).
* If you override this, you should call
* super.checkPackageDefinition before doing anything else.
*
* @param packageName the package name to check access to
* @throws SecurityException if permission is denied
* @throws NullPointerException if packageName is null
* @see ClassLoader#loadClass(String, boolean)
* @see Security#getProperty(String)
*/
public void checkPackageDefinition(String packageName)
{
checkPackageList(packageName, "package.definition", "defineClassInPackage.");
}
/**
* Check if the current thread is allowed to set the current socket factory.
* This method is called by Socket.setSocketImplFactory(),
* ServerSocket.setSocketFactory(), and URL.setURLStreamHandlerFactory().
* The default implementation checks
* RuntimePermission("setFactory"). If you override this, call
* super.checkSetFactory rather than throwing an exception.
*
* @throws SecurityException if permission is denied
* @see Socket#setSocketImplFactory(SocketImplFactory)
* @see ServerSocket#setSocketFactory(SocketImplFactory)
* @see URL#setURLStreamHandlerFactory(URLStreamHandlerFactory)
*/
public void checkSetFactory()
{
checkPermission(new RuntimePermission("setFactory"));
}
/**
* Check if the current thread is allowed to get certain types of Methods,
* Fields and Constructors from a Class object. This method is called by
* Class.getMethod[s](), Class.getField[s](), Class.getConstructor[s],
* Class.getDeclaredMethod[s](), Class.getDeclaredField[s](), and
* Class.getDeclaredConstructor[s](). The default implementation allows
* PUBLIC access, and access to classes defined by the same classloader as
* the code performing the reflection. Otherwise, it checks
* RuntimePermission("accessDeclaredMembers"). If you override
* this, do not call super.checkMemberAccess, as this would
* mess up the stack depth check that determines the ClassLoader requesting
* the access.
*
* @param c the Class to check
* @param memberType either DECLARED or PUBLIC
* @throws SecurityException if permission is denied, including when
* memberType is not DECLARED or PUBLIC
* @throws NullPointerException if c is null
* @see Class
* @see Member#DECLARED
* @see Member#PUBLIC
* @since 1.1
*/
public void checkMemberAccess(Class c, int memberType)
{
if (c == null)
throw new NullPointerException();
if (memberType == Member.PUBLIC)
return;
// XXX Allow access to classes created by same classloader before next
// check.
checkPermission(new RuntimePermission("accessDeclaredMembers"));
}
/**
* Test whether a particular security action may be taken. The default
* implementation checks SecurityPermission(action). If you
* override this, call super.checkSecurityAccess rather than
* throwing an exception.
*
* @param action the desired action to take
* @throws SecurityException if permission is denied
* @throws NullPointerException if action is null
* @throws IllegalArgumentException if action is ""
* @since 1.1
*/
public void checkSecurityAccess(String action)
{
checkPermission(new SecurityPermission(action));
}
/**
* Get the ThreadGroup that a new Thread should belong to by default. Called
* by Thread.Thread(). The default implementation returns the current
* ThreadGroup of the current Thread. Spec Note: it is not
* clear whether the new Thread is guaranteed to pass the
* checkAccessThreadGroup() test when using this ThreadGroup, but I presume
* so.
*
* @return the ThreadGroup to put the new Thread into
* @since 1.1
*/
public ThreadGroup getThreadGroup()
{
return Thread.currentThread().getThreadGroup();
}
/**
* Helper that checks a comma-separated list of restricted packages, from
* Security.getProperty("package.definition"), for the given
* package access permission. If packageName starts with or equals any
* restricted package, it checks
* RuntimePermission(permission + packageName).
*
* @param packageName the package name to check access to
* @param restriction "package.access" or "package.definition"
* @param permission the base permission, including the '.'
* @throws SecurityException if permission is denied
* @throws NullPointerException if packageName is null
* @see #checkPackageAccess(String)
* @see #checkPackageDefinition(String)
*/
void checkPackageList(String packageName, final String restriction,
String permission)
{
if (packageName == null)
throw new NullPointerException();
String list = (String)AccessController.doPrivileged(new PrivilegedAction()
{
public Object run()
{
return Security.getProperty(restriction);
}
});
if (list == null || list.equals(""))
return;
String packageNamePlusDot = packageName + ".";
StringTokenizer st = new StringTokenizer(list, ",");
while (st.hasMoreTokens())
{
if (packageNamePlusDot.startsWith(st.nextToken()))
{
Permission p = new RuntimePermission(permission + packageName);
checkPermission(p);
return;
}
}
}
}