Added basic Java implementation for these system classes.

1 files changed, 734 insertions, 0 deletions

diff --git a/java/lang/SecurityManager.java b/java/lang/SecurityManager.java
new file mode 100644
index 000000000..df33ac68d
--- /dev/null
+++ b/java/lang/SecurityManager.java
@@ -0,0 +1,734 @@
+/*
+ * java.lang.SecurityManager: part of the Java Class Libraries project.
+ * Copyright (C) 1998 John Keiser
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA  02111-1307, USA.
+ */
+
+package java.lang;
+
+import java.net.*;
+import java.util.*;
+import java.io.*;
+
+/**
+ ** 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 abstract class deny all
+ ** things to all people.
+ **
+ ** @author  John Keiser
+ ** @version 1.1.0, 31 May 1998
+ **/
+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;
+	}
+
+	/** 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 gnu.java.lang.ExecutionStack.getClasses();
+	}
+
+	/** 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() {
+		Class[] c = getClassContext();
+		for(int i=0;i<c.length;i++) {
+			if(c[i].getClassLoader() != null) {
+				return c[i].getClassLoader();
+			}
+		}
+		return null;
+	}
+
+	/** 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());
+	}
+
+	/** 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, int ttl) {
+		throw new SecurityException("Cannot read or write multicast.");
+	}
+
+	/** 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
+	 ** @exception SecurityException if the operation is not
+	 **            permitted.
+	 ** @see java.awt.Window#Window(java.awt.Frame)
+	 **/
+	public void checkTopLevelWindow(Object window) {
+		throw new SecurityException("Not trusted to create top-level window.");
+	}
+
+	/** 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) {
+	}
+
+	/** 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();
+	}
+}
+
+class SecurityContext {
+	Class[] classes;
+	SecurityContext(Class[] classes) {
+		this.classes = classes;
+	}
+}