-/* Copyright (C) 1998, 1999 Free Software Foundation
+/* java.lang.SecurityManager
+ Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
- This file is part of libgcj.
+This file is part of GNU Classpath.
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-// SecurityManager
package java.lang;
+import java.net.*;
+import java.util.*;
+import java.io.*;
+
/**
- * @author Anthony Green <green@cygnus.com>
- * @date October 5, 1998.
- */
+ ** SecurityManager is a class you can extend to create
+ ** your own Java security policy. By default, there is
+ ** no SecurityManager installed in 1.1, which means that
+ ** all things are permitted to all people.<P>
+ **
+ ** The default methods in this class deny all
+ ** things to all people.
+ **
+ ** @author John Keiser
+ ** @version 1.1.0, 31 May 1998
+ ** @since JDK1.0
+ **/
+public class SecurityManager {
+ /** Tells whether or not the SecurityManager is currently
+ ** performing a security check.
+ **/
+ protected boolean inCheck;
+
+ /** Tells whether or not the SecurityManager is currently
+ ** performing a security check.
+ **
+ ** @return whether or not the SecurityManager is
+ ** currently performing a security check.
+ **/
+ public boolean getInCheck() {
+ return inCheck;
+ }
-/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
- */
+ /** Get a list of all the classes currently executing
+ ** methods on the Java stack. getClassContext()[0] is
+ ** the currently executing method
+ ** <STRONG>Spec Note:</STRONG> does not say whether
+ ** the stack will include the getClassContext() call or
+ ** the one just before it.
+ **
+ ** @return an array containing all the methods on classes
+ ** on the Java execution stack.
+ **/
+ protected Class[] getClassContext() {
+ return VMSecurityManager.getClassContext();
+ }
-import java.io.*;
-import java.net.*;
+ /** Find the ClassLoader for the most recent class on the
+ ** stack that was loaded by an explicit ClassLoader. If
+ ** everything on the stack was loaded by the system
+ ** classloader, null is returned.
+ **
+ ** @return the most recent ClassLoader on the execution
+ ** stack.
+ **/
+ protected ClassLoader currentClassLoader() {
+ return VMSecurityManager.currentClassLoader();
+ }
+
+ /** Find the most recent class on the stack that was
+ ** loaded by an explicit ClassLoader. If everything on
+ ** the stack was loaded by the system classloader, null
+ ** is returned.
+ **
+ ** @return the most recent loaded Class on the execution
+ ** stack.
+ **/
+ protected Class currentLoadedClass() {
+ Class[] c = getClassContext();
+ for(int i=0;i<c.length;i++) {
+ if(c[i].getClassLoader() != null) {
+ return c[i];
+ }
+ }
+ return null;
+ }
+
+ /** Get the depth on the execution stack of the most
+ ** recent class that was loaded by an explicit
+ ** ClassLoader. This can be used as an index into
+ ** getClassContext().
+ **
+ ** @return the index of the most recent loaded Class on
+ ** the execution stack.
+ **/
+ protected int classLoaderDepth() {
+ Class[] c = getClassContext();
+ for(int i=0;i<c.length;i++) {
+ if(c[i].getClassLoader() != null) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ /** Tell whether there is a class loaded with an explicit
+ ** ClassLoader on the stack.
+ **
+ ** @return whether there is a class loaded with an
+ ** explicit ClassLoader on the stack.
+ **/
+ protected boolean inClassLoader() {
+ return classLoaderDepth() != -1;
+ }
+
+
+ /** Get the depth of a particular class on the execution
+ ** stack.
+ **
+ ** @param className the fully-qualified name of the class
+ ** to search for on the stack.
+ ** @return the index of the class on the stack, or -1 if
+ ** the class is not on the stack.
+ **/
+ protected int classDepth(String className) {
+ Class[] c = getClassContext();
+ for(int i=0;i<c.length;i++) {
+ if(className.equals(c[i].getName())) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ /** Tell whether the specified class is on the execution
+ ** stack.
+ **
+ ** @param className the fully-qualified name of the class
+ ** to search for on the stack.
+ ** @return whether the specified class is on the
+ ** execution stack.
+ **/
+ protected boolean inClass(String className) {
+ return classDepth(className) != -1;
+ }
+
+ /** Get an implementation-dependent Object that contains
+ ** enough information about the current environment to be
+ ** able to perform standard security checks later. This
+ ** is used by trusted methods that need to verify that
+ ** their callers have sufficient access to perform
+ ** certain operations.<P>
+ **
+ ** Currently the only methods that use this are checkRead()
+ ** and checkConnect().
+ **
+ ** @see checkConnect(java.lang.String,int,java.lang.Object)
+ ** @see checkRead(java.lang.String,java.lang.Object)
+ **/
+ public Object getSecurityContext() {
+ return new SecurityContext(getClassContext());
+ }
-public abstract class SecurityManager
-{
- protected boolean inCheck = false;
-
- public void checkAccept (String host, int port)
- {
- throw new SecurityException();
- }
-
- public void checkAccess (Thread thrd)
- {
- throw new SecurityException();
- }
-
- public void checkAccess (ThreadGroup thrdGroup)
- {
- throw new SecurityException();
- }
-
- public void checkAwtEventQueueAccess ()
- {
- throw new SecurityException();
- }
-
- public void checkConnect (String host, int prt)
- {
- throw new SecurityException();
- }
-
- public void checkConnect (String host, int prt, Object ctx)
- {
- throw new SecurityException();
- }
-
- public void checkCreateClassLoader ()
- {
- throw new SecurityException();
- }
-
- public void checkDelete (String fileName)
- {
- throw new SecurityException();
- }
-
- public void checkExec (String prog)
- {
- throw new SecurityException();
- }
-
- public void checkExit (int stat)
- {
- throw new SecurityException();
- }
-
- public void checkLink (String lib)
- {
- throw new SecurityException();
- }
-
- public void checkListen (int lport)
- {
- throw new SecurityException();
- }
-
- public void checkMemberAccess (Class cl, int mtype)
- {
- throw new SecurityException();
- }
-
- public void checkMulticast (InetAddress maddr)
- {
- throw new SecurityException();
- }
-
- public void checkMulticast (InetAddress maddr, byte ttl)
- {
- throw new SecurityException();
- }
-
- public void checkPackageAccess (String pkg)
- {
- throw new SecurityException();
- }
-
- public void checkPackageDefinition (String pkg)
- {
- throw new SecurityException();
- }
-
- public void checkPermission (java.security.Permission perm)
- {
- throw new SecurityException();
- }
-
- public void checkPrintJobAccess ()
- {
- throw new SecurityException();
- }
-
- public void checkPropertiesAccess ()
- {
- throw new SecurityException();
- }
-
- public void checkPropertyAccess (String prop)
- {
- throw new SecurityException();
- }
-
- public void checkPropertyAccess (String prop, String defval)
- {
- throw new SecurityException();
- }
-
- public void checkRead (FileDescriptor fd)
- {
- throw new SecurityException();
- }
-
- public void checkRead (String fileName)
- {
- throw new SecurityException();
- }
-
- public void checkRead (String fileName, Object ctx)
- {
- throw new SecurityException();
- }
-
- public void checkSecurityAccess (String action)
- {
- throw new SecurityException();
- }
-
- public void checkSetFactory ()
- {
- throw new SecurityException();
- }
-
- public void checkSystemClipboardAccess ()
- {
- throw new SecurityException();
- }
-
- public boolean checkTopLevelWindow (Object window)
- {
- throw new SecurityException();
- }
-
- public void checkWrite (FileDescriptor fd)
- {
- throw new SecurityException();
- }
-
- public void checkWrite (String fileName)
- {
- throw new SecurityException();
- }
-
- // Note: this method is deprecated in JDK 1.2
- protected /* native */ int classDepth (String className)
- {
- Class[] classStack = getClassContext ();
- for (int i = 0; i < classStack.length; i++)
- if (classStack[i].getName().compareTo(className) == 0)
- return i;
-
- return -1;
- }
-
- // Note: this method is deprecated in JDK 1.2
- protected /* native */ int classLoaderDepth ()
- {
- Class[] classStack = getClassContext ();
- for (int i = 0; i < classStack.length; i++)
- if (classStack[i].getClassLoader() != null)
- return i;
-
- return -1;
- }
-
- protected /* native */ ClassLoader currentClassLoader ()
- {
- Class[] classStack = getClassContext ();
- for (int i = 0; i < classStack.length; i++)
- {
- ClassLoader loader = classStack[i].getClassLoader();
- if (loader != null)
- return loader;
- }
-
- return null;
- }
-
- protected /* native */ Class currentLoadedClass ()
- {
- Class[] classStack = getClassContext ();
- for (int i = 0; i < classStack.length; i++)
- {
- ClassLoader loader = classStack[i].getClassLoader();
- if (loader != null)
- return classStack[i];
- }
-
- return null;
- }
-
- protected /* native */ Class[] getClassContext ()
- {
- return new Class[0];
- }
-
- // Note: this method is deprecated in JDK 1.2
- public boolean getInCheck ()
- {
- return inCheck;
- }
-
- public Object getSecurityContext ()
- {
- // FIXME: This has yet to be implemented.
- return new String("");
- }
-
- public ThreadGroup getThreadGroup ()
- {
- return Thread.currentThread().getThreadGroup();
- }
-
- protected boolean inClass (String className)
- {
- return (classDepth (className) != -1);
- }
-
- protected boolean inClassLoader ()
- {
- return (classLoaderDepth () != -1);
- }
-
- protected SecurityManager ()
- {
- if (System.getSecurityManager () != null)
- throw new SecurityException ();
- }
+ /** Check if the current thread is allowed to create a
+ ** ClassLoader.<P>
+ **
+ ** This method is called from ClassLoader.ClassLoader(),
+ ** in other words, whenever a ClassLoader is created.<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.ClassLoader#ClassLoader()
+ **/
+ public void checkCreateClassLoader() {
+ throw new SecurityException("Cannot create new ClassLoaders.");
+ }
+
+ /** Check if the current thread is allowed to modify this
+ ** other Thread.<P>
+ **
+ ** Called by Thread.stop(), suspend(), resume(), and
+ ** interrupt(), destroy(), setPriority(), setName() and
+ ** setDaemon().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param g the Thread to check against
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.Thread#stop()
+ ** @see java.lang.Thread#suspend()
+ ** @see java.lang.Thread#resume()
+ ** @see java.lang.Thread#interrupt()
+ ** @see java.lang.Thread#destroy()
+ ** @see java.lang.Thread#setPriority(int)
+ ** @see java.lang.Thread#setName(java.lang.String)
+ ** @see java.lang.Thread#setDaemon(boolean)
+ **/
+ public void checkAccess(Thread t) {
+ throw new SecurityException("Cannot modify Threads.");
+ }
+
+ /** Check if the current thread is allowed to modify this
+ ** ThreadGroup.<P>
+ **
+ ** 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().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param g the ThreadGroup to check against
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.Thread#Thread()
+ ** @see java.lang.ThreadGroup#ThreadGroup()
+ ** @see java.lang.ThreadGroup#stop()
+ ** @see java.lang.ThreadGroup#suspend()
+ ** @see java.lang.ThreadGroup#resume()
+ ** @see java.lang.ThreadGroup#interrupt()
+ ** @see java.lang.ThreadGroup#setDaemon(boolean)
+ ** @see java.lang.ThreadGroup#setMaxPriority(int)
+ **/
+ public void checkAccess(ThreadGroup g) {
+ throw new SecurityException("Cannot modify ThreadGroups.");
+ }
+
+ /** Check if the current thread is allowed to exit the
+ ** JVM with the given status.<P>
+ **
+ ** This method is called from Runtime.exit().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param status the status to exit with
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.Runtime#exit()
+ ** @see java.lang.Runtime#exit(int)
+ **/
+ public void checkExit(int status) {
+ throw new SecurityException("Cannot exit JVM.");
+ }
+
+ /** Check if the current thread is allowed to execute the
+ ** given program.<P>
+ **
+ ** This method is called from Runtime.exec().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param program the name of the program to exec
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.Runtime#exec(java.lang.String[],java.lang.String[])
+ **/
+ public void checkExec(String program) {
+ throw new SecurityException("Cannot execute programs.");
+ }
+
+ /** Check if the current thread is allowed to link in the
+ ** given native library.<P>
+ **
+ ** This method is called from Runtime.load() (and hence,
+ ** by loadLibrary() as well).<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param filename the full name of the library to load
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.Runtime#load(java.lang.String)
+ **/
+ public void checkLink(String filename) {
+ throw new SecurityException("Cannot link native libraries.");
+ }
+
+ /** Check if the current thread is allowed to read the
+ ** given file using the FileDescriptor.<P>
+ **
+ ** This method is called from
+ ** FileInputStream.FileInputStream().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param desc the FileDescriptor representing the file
+ ** to access
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.io.FileInputStream#FileInputStream(java.io.FileDescriptor)
+ **/
+ public void checkRead(FileDescriptor desc) {
+ throw new SecurityException("Cannot read files via file descriptors.");
+ }
+
+ /** Check if the current thread is allowed to read the
+ ** given file.<P>
+ **
+ ** This method is called from
+ ** FileInputStream.FileInputStream(),
+ ** RandomAccessFile.RandomAccessFile(), File.exists(),
+ ** canRead(), isFile(), isDirectory(), lastModified(),
+ ** length() and list().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param filename the full name of the file to access
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.io.File
+ ** @see java.io.FileInputStream#FileInputStream(java.lang.String)
+ ** @see java.io.RandomAccessFile#RandomAccessFile(java.lang.String)
+ **/
+ public void checkRead(String filename) {
+ throw new SecurityException("Cannot read files via file names.");
+ }
+
+ /** Check if the current thread is allowed to read the
+ ** given file. using the given SecurityContext.<P>
+ **
+ ** I know of no core class that calls this method.<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param filename the full name of the file to access
+ ** @param securityContext the Security Context to
+ ** determine access for.
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ **/
+ public void checkRead(String filename, Object securityContext) {
+ throw new SecurityException("Cannot read files via file names.");
+ }
+
+ /** Check if the current thread is allowed to write to the
+ ** given file using the FileDescriptor.<P>
+ **
+ ** This method is called from
+ ** FileOutputStream.FileOutputStream().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param desc the FileDescriptor representing the file
+ ** to access
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.io.FileOutputStream#FileOutputStream(java.io.FileDescriptor)
+ **/
+ public void checkWrite(FileDescriptor desc) {
+ throw new SecurityException("Cannot write files via file descriptors.");
+ }
+
+ /** Check if the current thread is allowed to write to the
+ ** given file.<P>
+ **
+ ** This method is called from
+ ** FileOutputStream.FileOutputStream(),
+ ** RandomAccessFile.RandomAccessFile(),
+ ** File.canWrite(), mkdir(), and renameTo().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param filename the full name of the file to access
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.io.File#canWrite()
+ ** @see java.io.File#mkdir()
+ ** @see java.io.File#renameTo()
+ ** @see java.io.FileOutputStream#FileOutputStream(java.lang.String)
+ ** @see java.io.RandomAccessFile#RandomAccessFile(java.lang.String)
+ **/
+ public void checkWrite(String filename) {
+ throw new SecurityException("Cannot write files via file names.");
+ }
+
+ /** Check if the current thread is allowed to delete the
+ ** given file.<P>
+ **
+ ** This method is called from File.delete().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param filename the full name of the file to delete
+ ** @exception SecurityException if th operation is not
+ ** permitted.
+ ** @see java.io.File#delete()
+ **/
+ public void checkDelete(String filename) {
+ throw new SecurityException("Cannot delete files.");
+ }
+
+ /** Check if the current thread is allowed to connect to a
+ ** given host on a given port.<P>
+ **
+ ** This method is called from Socket.Socket().
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param host the host to connect to
+ ** @param port the port to connect on
+ ** @exception SecurityException if the operation is not
+ ** permitted
+ ** @see java.net.Socket#Socket()
+ **/
+ public void checkConnect(String host, int port) {
+ throw new SecurityException("Cannot make network connections.");
+ }
+
+ /** Check if the current thread is allowed to connect to a
+ ** given host on a given port using a specific security
+ ** context to determine access.<P>
+ **
+ ** This method is not called in the 1.1 core classes.<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param host the host to connect to
+ ** @param port the port to connect on
+ ** @param securityContext the security context to
+ ** determine access with
+ ** @exception SecurityException if the operation is not
+ ** permitted
+ **/
+ public void checkConnect(String host, int port, Object securityContext) {
+ throw new SecurityException("Cannot make network connections.");
+ }
+
+ /** Check if the current thread is allowed to listen to a
+ ** specific port for data.<P>
+ **
+ ** This method is called by ServerSocket.ServerSocket().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param port the port to listen on
+ ** @exception SecurityException if the operation is not
+ ** permitted
+ ** @see java.net.ServerSocket#ServerSocket(int)
+ **/
+ public void checkListen(int port) {
+ throw new SecurityException("Cannot listen for connections.");
+ }
+
+ /** Check if the current thread is allowed to accept a
+ ** connection from a particular host on a particular
+ ** port.<P>
+ **
+ ** This method is called by ServerSocket.implAccept().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param host the host which wishes to connect
+ ** @param port the port the connection will be on
+ ** @exception SecurityException if the operation is not
+ ** permitted
+ ** @see java.net.ServerSocket#accept()
+ **/
+ public void checkAccept(String host, int port) {
+ throw new SecurityException("Cannot accept connections.");
+ }
+
+ /** Check if the current thread is allowed to read and
+ ** write multicast to a particular address.<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @XXX where is it called?
+ **
+ ** @param addr the address to multicast to.
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ **/
+ public void checkMulticast(InetAddress addr) {
+ throw new SecurityException("Cannot read or write multicast.");
+ }
+
+ /** Check if the current thread is allowed to read and
+ ** write multicast to a particular address with a
+ ** particular ttl value.<P>
+ **
+ ** SecurityManager's implementation always denies access.<P>
+ **
+ ** @XXX where is it called?
+ **
+ ** @XXX what the hell is ttl? Expand abbreviation.
+ **
+ ** @param addr the address to multicast to.
+ ** @param ttl the ttl value to use
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ **/
+ public void checkMulticast(InetAddress addr, byte ttl) {
+ throw new SecurityException("Cannot read or write multicast.");
+ }
+
+ /**
+ ** Check if the current thread is allowed to perform an
+ ** operation that requires the specified <code>Permission</code>.
+ **
+ ** @param perm The <code>Permission</code> required.
+ ** @exception SecurityException If the operation is not allowed.
+ **/
+ public void checkPermission(java.security.Permission perm) {
+ throw new SecurityException("Operation not allowed");
+ }
+
+ /**
+ ** Check if the current thread is allowed to perform an
+ ** operation that requires the specified <code>Permission</code>.
+ **
+ ** @param perm The <code>Permission</code> required.
+ ** @param context A security context
+ ** @exception SecurityException If the operation is not allowed.
+ ** @since 1.2
+ **/
+ public void checkPermission(java.security.Permission perm,
+ Object context) {
+ throw new SecurityException("Operation not allowed");
+ }
+
+ /** Check if the current thread is allowed to read or
+ ** write all the system properties at once.<P>
+ **
+ ** This method is called by System.getProperties()
+ ** and setProperties().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.System#getProperties()
+ ** @see java.lang.System#setProperties(java.util.Properties)
+ **/
+ public void checkPropertiesAccess() {
+ throw new SecurityException("Cannot access all system properties at once.");
+ }
+
+ /** Check if the current thread is allowed to read or
+ ** write a particular system property.<P>
+ **
+ ** This method is called by System.getProperty() and
+ ** setProperty().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @exception SecurityException is the operation is not
+ ** permitted.
+ ** @see java.lang.System#getProperty(java.lang.String)
+ ** @see java.lang.System#setProperty(java.lang.String,java.lang.String)
+ **/
+ public void checkPropertyAccess(String name) {
+ throw new SecurityException("Cannot access individual system properties.");
+ }
+
+ /** 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.<P>
+ **
+ ** This method is called by Window.Window().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param window the window to create
+ ** @see java.awt.Window#Window(java.awt.Frame)
+ **/
+ public boolean checkTopLevelWindow(Object window) {
+ return false;
+ }
+
+ /** Check if the current thread is allowed to create a
+ ** print job.<P>
+ **
+ ** This method is called by Toolkit.getPrintJob(). (I
+ ** assume so, at least, it just don't say nothing about
+ ** it in the spec.)<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.awt.Toolkit.getPrintJob(java.awt.Frame,java.lang.String,java.util.Properties)
+ **/
+ public void checkPrintJobAccess() {
+ throw new SecurityException("Cannot create print jobs.");
+ }
+
+ /** Check if the current thread is allowed to use the
+ ** system clipboard.<P>
+ **
+ ** This method is called by Toolkit.getSystemClipboard().
+ ** (I assume.)<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.awt.Toolkit#getSystemClipboard()
+ **/
+ public void checkSystemClipboardAccess() {
+ throw new SecurityException("Cannot access the system clipboard.");
+ }
+
+ /** Check if the current thread is allowed to use the AWT
+ ** event queue.<P>
+ **
+ ** This method is called by Toolkit.getSystemEventQueue().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.awt.Toolkit#getSystemEventQueue()
+ **/
+ public void checkAwtEventQueueAccess() {
+ throw new SecurityException("Cannot access the AWT event queue.");
+ }
+
+ /** Check if the current thread is allowed to access the
+ ** specified package at all.<P>
+ **
+ ** This method is called by ClassLoader.loadClass() in
+ ** user-created ClassLoaders.<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param packageName the package name to check access to
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.ClassLoader#loadClass(java.lang.String,boolean)
+ **/
+ public void checkPackageAccess(String packageName) {
+ throw new SecurityException("Cannot access packages via the ClassLoader.");
+ }
+
+ /** Check if the current thread is allowed to define
+ ** classes the specified package. If the class already
+ ** created, though, ClassLoader.loadClass() can still
+ ** return the Class if checkPackageAccess() checks out.<P>
+ **
+ ** This method is called by ClassLoader.loadClass() in
+ ** user-created ClassLoaders.<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param packageName the package name to check access to
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.ClassLoader#loadClass(java.lang.String,boolean)
+ **/
+ public void checkPackageDefinition(String packageName) {
+ throw new SecurityException("Cannot load classes into any packages via the ClassLoader.");
+ }
+
+ /** Check if the current thread is allowed to set the
+ ** current socket factory.<P>
+ **
+ ** This method is called by Socket.setSocketImplFactory(),
+ ** ServerSocket.setSocketFactory(), and
+ ** URL.setURLStreamHandlerFactory().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
+ ** @see java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)
+ ** @see java.net.URL#setURLStreamHandlerFactory(java.net.URLStreamHandlerFactory)
+ **/
+ public void checkSetFactory() {
+ throw new SecurityException("Cannot set the socket factory.");
+ }
+
+ /** Check if the current thread is allowed to get certain
+ ** types of Methods, Fields and Constructors from a Class
+ ** object.<P>
+ **
+ ** This method is called by Class.getMethod[s](),
+ ** Class.getField[s](), Class.getConstructor[s],
+ ** Class.getDeclaredMethod[s](),
+ ** Class.getDeclaredField[s](), and
+ ** Class.getDeclaredConstructor[s]().<P>
+ **
+ ** SecurityManager's implementation always denies access.
+ **
+ ** @param c the Class to check
+ ** @param memberType the type of members to check
+ ** against, either Member.DECLARED or
+ ** Member.PUBLIC.
+ ** @exception SecurityException if the operation is not
+ ** permitted.
+ ** @see java.lang.Class
+ ** @see java.lang.reflect.Member#DECLARED
+ ** @see java.lang.reflect.Member#PUBLIC
+ **/
+ public void checkMemberAccess(Class c, int memberType) {
+ throw new SecurityException("Cannot access members of classes.");
+ }
+
+ /** Test whether a particular security action may be
+ ** taken.
+ ** @param action the desired action to take
+ ** @exception SecurityException if the action is denied.
+ ** @XXX I have no idea what actions must be tested
+ ** or where.
+ **/
+ public void checkSecurityAccess(String action) {
+ checkPermission (new java.security.SecurityPermission (action));
+ }
+
+ /** Get the ThreadGroup that a new Thread should belong
+ ** to by default.<P>
+ **
+ ** Called by Thread.Thread().<P>
+ **
+ ** SecurityManager's implementation just uses the
+ ** ThreadGroup of the current Thread.<P>
+ **
+ ** <STRONG>Spec Note:</STRONG> it is not clear whether
+ ** the new Thread is guaranteed to pass the
+ ** checkAccessThreadGroup() test when using this
+ ** ThreadGroup. I presume so.
+ **
+ ** @return the ThreadGroup to put the new Thread into.
+ **/
+ public ThreadGroup getThreadGroup() {
+ return Thread.currentThread().getThreadGroup();
+ }
+
+ protected SecurityManager () {
+ if (System.getSecurityManager () != null)
+ throw new SecurityException ();
+ }
+}
+
+class SecurityContext {
+ Class[] classes;
+ SecurityContext(Class[] classes) {
+ this.classes = classes;
+ }
}
OSDN Git Service
