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()
{
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().getParent() == 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.getParent() == 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;
}
}
}
}