public SecurityManager() 
{
        synchronized(SecurityManager.class) {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                // ask the currently installed security manager if we
                // can create a new one.
                sm.checkPermission(new RuntimePermission
                                   ("createSecurityManager"));
            }
            initialized = true;
        }
}

Constructs a new SecurityManager.

If there is a security manager already installed, this method first calls the security manager's checkPermission method with the RuntimePermission("createSecurityManager") permission to ensure the calling thread has permission to create a new security manager. This may result in throwing a SecurityException.

Throws:

java.lang.SecurityException - if a security manager already exists and its checkPermission method doesn't allow creation of a new security manager.

Also see:

java.lang.System#getSecurityManager()
checkPermission(java.security.Permission) checkPermission
java.lang.RuntimePermission
exception: java.lang.SecurityException - if a security manager already exists and its checkPermission method doesn't allow creation of a new security manager.

 public  void checkAccept(String host,
    int port) 
{
        if (host == null) {
            throw new NullPointerException("host can't be null");
        }
        if (!host.startsWith("[") && host.indexOf(':') != -1) {
            host = "[" + host + "]";
        }
        checkPermission(new SocketPermission(host+":"+port,
            SecurityConstants.SOCKET_ACCEPT_ACTION));
}

Throws a SecurityException if the calling thread is not permitted to accept a socket connection from the specified host and port number.

This method is invoked for the current security manager by the accept method of class ServerSocket.

This method calls checkPermission with the SocketPermission(host+":"+port,"accept") permission.

If you override this method, then you should make a call to super.checkAccept at the point the overridden method would normally throw an exception.

 public  void checkAccess(Thread t) 
{
        if (t == null) {
            throw new NullPointerException("thread can't be null");
        }
        if (t.getThreadGroup() == rootGroup) {
            checkPermission(SecurityConstants.MODIFY_THREAD_PERMISSION);
        } else {
            // just return
        }
}

Throws a SecurityException if the calling thread is not allowed to modify the thread argument.

This method is invoked for the current security manager by the stop, suspend, resume, setPriority, setName, and setDaemon methods of class Thread.

If the thread argument is a system thread (belongs to the thread group with a null parent) then this method calls checkPermission with the RuntimePermission("modifyThread") permission. If the thread argument is not a system thread, this method just returns silently.

Applications that want a stricter policy should override this method. If this method is overridden, the method that overrides it should additionally check to see if the calling thread has the RuntimePermission("modifyThread") permission, and if so, return silently. This is to ensure that code granted that permission (such as the JDK itself) is allowed to manipulate any thread.

If this method is overridden, then super.checkAccess should be called by the first statement in the overridden method, or the equivalent security check should be placed in the overridden method.

 public  void checkAccess(ThreadGroup g) 
{
        if (g == null) {
            throw new NullPointerException("thread group can't be null");
        }
        if (g == rootGroup) {
            checkPermission(SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
        } else {
            // just return
        }
}

Throws a SecurityException if the calling thread is not allowed to modify the thread group argument.

This method is invoked for the current security manager when a new child thread or child thread group is created, and by the setDaemon, setMaxPriority, stop, suspend, resume, and destroy methods of class ThreadGroup.

If the thread group argument is the system thread group ( has a null parent) then this method calls checkPermission with the RuntimePermission("modifyThreadGroup") permission. If the thread group argument is not the system thread group, this method just returns silently.

Applications that want a stricter policy should override this method. If this method is overridden, the method that overrides it should additionally check to see if the calling thread has the RuntimePermission("modifyThreadGroup") permission, and if so, return silently. This is to ensure that code granted that permission (such as the JDK itself) is allowed to manipulate any thread.

If this method is overridden, then super.checkAccess should be called by the first statement in the overridden method, or the equivalent security check should be placed in the overridden method.

 public  void checkAwtEventQueueAccess() 
{
        checkPermission(SecurityConstants.AWT.CHECK_AWT_EVENTQUEUE_PERMISSION);
}

Throws a SecurityException if the calling thread is not allowed to access the AWT event queue.

This method calls checkPermission with the AWTPermission("accessEventQueue") permission.

If you override this method, then you should make a call to super.checkAwtEventQueueAccess at the point the overridden method would normally throw an exception.

 public  void checkConnect(String host,
    int port) 
{
        if (host == null) {
            throw new NullPointerException("host can't be null");
        }
        if (!host.startsWith("[") && host.indexOf(':') != -1) {
            host = "[" + host + "]";
        }
        if (port == -1) {
            checkPermission(new SocketPermission(host,
                SecurityConstants.SOCKET_RESOLVE_ACTION));
        } else {
            checkPermission(new SocketPermission(host+":"+port,
                SecurityConstants.SOCKET_CONNECT_ACTION));
        }
}

Throws a SecurityException if the calling thread is not allowed to open a socket connection to the specified host and port number.

A port number of -1 indicates that the calling method is attempting to determine the IP address of the specified host name.

This method calls checkPermission with the SocketPermission(host+":"+port,"connect") permission if the port is not equal to -1. If the port is equal to -1, then it calls checkPermission with the SocketPermission(host,"resolve") permission.

If you override this method, then you should make a call to super.checkConnect at the point the overridden method would normally throw an exception.

 public  void checkConnect(String host,
    int port,
    Object context) 
{
        if (host == null) {
            throw new NullPointerException("host can't be null");
        }
        if (!host.startsWith("[") && host.indexOf(':') != -1) {
            host = "[" + host + "]";
        }
        if (port == -1)
            checkPermission(new SocketPermission(host,
                SecurityConstants.SOCKET_RESOLVE_ACTION),
                context);
        else
            checkPermission(new SocketPermission(host+":"+port,
                SecurityConstants.SOCKET_CONNECT_ACTION),
                context);
}

Throws a SecurityException if the specified security context is not allowed to open a socket connection to the specified host and port number.

A port number of -1 indicates that the calling method is attempting to determine the IP address of the specified host name.

If context is not an instance of AccessControlContext then a SecurityException is thrown.

Otherwise, the port number is checked. If it is not equal to -1, the context's checkPermission method is called with a SocketPermission(host+":"+port,"connect") permission. If the port is equal to -1, then the context's checkPermission method is called with a SocketPermission(host,"resolve") permission.

If you override this method, then you should make a call to super.checkConnect at the point the overridden method would normally throw an exception.

 public  void checkCreateClassLoader() 
{
        checkPermission(SecurityConstants.CREATE_CLASSLOADER_PERMISSION);
}

Throws a SecurityException if the calling thread is not allowed to create a new class loader.

This method calls checkPermission with the RuntimePermission("createClassLoader") permission.

If you override this method, then you should make a call to super.checkCreateClassLoader at the point the overridden method would normally throw an exception.

 public  void checkDelete(String file) 
{
        checkPermission(new FilePermission(file,
            SecurityConstants.FILE_DELETE_ACTION));
}

Throws a SecurityException if the calling thread is not allowed to delete the specified file.

This method is invoked for the current security manager by the delete method of class File.

This method calls checkPermission with the FilePermission(file,"delete") permission.

If you override this method, then you should make a call to super.checkDelete at the point the overridden method would normally throw an exception.

 public  void checkExec(String cmd) 
{
        File f = new File(cmd);
        if (f.isAbsolute()) {
            checkPermission(new FilePermission(cmd,
                SecurityConstants.FILE_EXECUTE_ACTION));
        } else {
            checkPermission(new FilePermission("< < ALL FILES > >",
                SecurityConstants.FILE_EXECUTE_ACTION));
        }
}

Throws a SecurityException if the calling thread is not allowed to create a subprocess.

This method is invoked for the current security manager by the exec methods of class Runtime.

This method calls checkPermission with the FilePermission(cmd,"execute") permission if cmd is an absolute path, otherwise it calls checkPermission with FilePermission("<<ALL FILES>>","execute").

If you override this method, then you should make a call to super.checkExec at the point the overridden method would normally throw an exception.

 public  void checkExit(int status) 
{
        checkPermission(new RuntimePermission("exitVM."+status));
}

Throws a SecurityException if the calling thread is not allowed to cause the Java Virtual Machine to halt with the specified status code.

This method is invoked for the current security manager by the exit method of class Runtime. A status of 0 indicates success; other values indicate various errors.

This method calls checkPermission with the RuntimePermission("exitVM."+status) permission.

If you override this method, then you should make a call to super.checkExit at the point the overridden method would normally throw an exception.

 public  void checkLink(String lib) 
{
        if (lib == null) {
            throw new NullPointerException("library can't be null");
        }
        checkPermission(new RuntimePermission("loadLibrary."+lib));
}

Throws a SecurityException if the calling thread is not allowed to dynamic link the library code specified by the string argument file. The argument is either a simple library name or a complete filename.

This method is invoked for the current security manager by methods load and loadLibrary of class Runtime.

This method calls checkPermission with the RuntimePermission("loadLibrary."+lib) permission.

If you override this method, then you should make a call to super.checkLink at the point the overridden method would normally throw an exception.

 public  void checkListen(int port) 
{
        if (port == 0) {
            checkPermission(SecurityConstants.LOCAL_LISTEN_PERMISSION);
        } else {
            checkPermission(new SocketPermission("localhost:"+port,
                SecurityConstants.SOCKET_LISTEN_ACTION));
        }
}

Throws a SecurityException if the calling thread is not allowed to wait for a connection request on the specified local port number.

If port is not 0, this method calls checkPermission with the SocketPermission("localhost:"+port,"listen"). If port is zero, this method calls checkPermission with SocketPermission("localhost:1024-","listen").

If you override this method, then you should make a call to super.checkListen at the point the overridden method would normally throw an exception.

 public  void checkMemberAccess(Class<?> clazz,
    int which) 
{
        if (clazz == null) {
            throw new NullPointerException("class can't be null");
        }
        if (which != Member.PUBLIC) {
            Class stack[] = getClassContext();
            /*
             * stack depth of 4 should be the caller of one of the
             * methods in java.lang.Class that invoke checkMember
             * access. The stack should look like:
             *
             * someCaller                        [3]
             * java.lang.Class.someReflectionAPI [2]
             * java.lang.Class.checkMemberAccess [1]
             * SecurityManager.checkMemberAccess [0]
             *
             */
            if ((stack.length< 4) ||
                (stack[3].getClassLoader() != clazz.getClassLoader())) {
                checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
            }
        }
}

Throws a SecurityException if the calling thread is not allowed to access members.

The default policy is to allow access to PUBLIC members, as well as access to classes that have the same class loader as the caller. In all other cases, this method calls checkPermission with the RuntimePermission("accessDeclaredMembers") permission.

If this method is overridden, then a call to super.checkMemberAccess cannot be made, as the default implementation of checkMemberAccess relies on the code being checked being at a stack depth of 4.

 public  void checkMulticast(InetAddress maddr) 
{
        String host = maddr.getHostAddress();
        if (!host.startsWith("[") && host.indexOf(':') != -1) {
            host = "[" + host + "]";
        }
        checkPermission(new SocketPermission(host,
            SecurityConstants.SOCKET_CONNECT_ACCEPT_ACTION));
}

Throws a SecurityException if the calling thread is not allowed to use (join/leave/send/receive) IP multicast.

This method calls checkPermission with the java.net.SocketPermission(maddr.getHostAddress(), "accept,connect") permission.

If you override this method, then you should make a call to super.checkMulticast at the point the overridden method would normally throw an exception.

 public  void checkMulticast(InetAddress maddr,
    byte ttl) 
{
        String host = maddr.getHostAddress();
        if (!host.startsWith("[") && host.indexOf(':') != -1) {
            host = "[" + host + "]";
        }
        checkPermission(new SocketPermission(host,
            SecurityConstants.SOCKET_CONNECT_ACCEPT_ACTION));
}

Throws a SecurityException if the calling thread is not allowed to use (join/leave/send/receive) IP multicast.

This method calls checkPermission with the java.net.SocketPermission(maddr.getHostAddress(), "accept,connect") permission.

If you override this method, then you should make a call to super.checkMulticast at the point the overridden method would normally throw an exception.

 public  void checkPackageAccess(String pkg) 
{
        if (pkg == null) {
            throw new NullPointerException("package name can't be null");
        }
        String[] pkgs;
        synchronized (packageAccessLock) {
            /*
             * Do we need to update our property array?
             */
            if (!packageAccessValid) {
                String tmpPropertyStr =
                    AccessController.doPrivileged(
                        new PrivilegedAction< String >() {
                            public String run() {
                                return java.security.Security.getProperty(
                                    "package.access");
                            }
                        }
                    );
                packageAccess = getPackages(tmpPropertyStr);
                packageAccessValid = true;
            }
            // Using a snapshot of packageAccess -- don't care if static field
            // changes afterwards; array contents won't change.
            pkgs = packageAccess;
        }
        /*
         * Traverse the list of packages, check for any matches.
         */
        for (int i = 0; i <  pkgs.length; i++) {
            if (pkg.startsWith(pkgs[i]) || pkgs[i].equals(pkg + ".")) {
                checkPermission(
                    new RuntimePermission("accessClassInPackage."+pkg));
                break;  // No need to continue; only need to check this once
            }
        }
}

Throws a SecurityException if the calling thread is not allowed to access the package specified by the argument.

This method is used by the loadClass method of class loaders.

This method first gets a list of restricted packages by obtaining a comma-separated list from a call to java.security.Security.getProperty("package.access"), and checks to see if pkg starts with or equals any of the restricted packages. If it does, then checkPermission gets called with the RuntimePermission("accessClassInPackage."+pkg) permission.

If this method is overridden, then super.checkPackageAccess should be called as the first line in the overridden method.

 public  void checkPackageDefinition(String pkg) 
{
        if (pkg == null) {
            throw new NullPointerException("package name can't be null");
        }
        String[] pkgs;
        synchronized (packageDefinitionLock) {
            /*
             * Do we need to update our property array?
             */
            if (!packageDefinitionValid) {
                String tmpPropertyStr =
                    AccessController.doPrivileged(
                        new PrivilegedAction< String >() {
                            public String run() {
                                return java.security.Security.getProperty(
                                    "package.definition");
                            }
                        }
                    );
                packageDefinition = getPackages(tmpPropertyStr);
                packageDefinitionValid = true;
            }
            // Using a snapshot of packageDefinition -- don't care if static
            // field changes afterwards; array contents won't change.
            pkgs = packageDefinition;
        }
        /*
         * Traverse the list of packages, check for any matches.
         */
        for (int i = 0; i <  pkgs.length; i++) {
            if (pkg.startsWith(pkgs[i]) || pkgs[i].equals(pkg + ".")) {
                checkPermission(
                    new RuntimePermission("defineClassInPackage."+pkg));
                break; // No need to continue; only need to check this once
            }
        }
}

Throws a SecurityException if the calling thread is not allowed to define classes in the package specified by the argument.

This method is used by the loadClass method of some class loaders.

This method first gets a list of restricted packages by obtaining a comma-separated list from a call to java.security.Security.getProperty("package.definition"), and checks to see if pkg starts with or equals any of the restricted packages. If it does, then checkPermission gets called with the RuntimePermission("defineClassInPackage."+pkg) permission.

If this method is overridden, then super.checkPackageDefinition should be called as the first line in the overridden method.

 public  void checkPermission(Permission perm) 
{
        java.security.AccessController.checkPermission(perm);
}

Throws a SecurityException if the requested access, specified by the given permission, is not permitted based on the security policy currently in effect.

This method calls AccessController.checkPermission with the given permission.

 public  void checkPermission(Permission perm,
    Object context) 
{
        if (context instanceof AccessControlContext) {
            ((AccessControlContext)context).checkPermission(perm);
        } else {
            throw new SecurityException();
        }
}

Throws a SecurityException if the specified security context is denied access to the resource specified by the given permission. The context must be a security context returned by a previous call to getSecurityContext and the access control decision is based upon the configured security policy for that security context.

If context is an instance of AccessControlContext then the AccessControlContext.checkPermission method is invoked with the specified permission.

If context is not an instance of AccessControlContext then a SecurityException is thrown.

 public  void checkPrintJobAccess() 
{
        checkPermission(new RuntimePermission("queuePrintJob"));
}

Throws a SecurityException if the calling thread is not allowed to initiate a print job request.

This method calls checkPermission with the RuntimePermission("queuePrintJob") permission.

If you override this method, then you should make a call to super.checkPrintJobAccess at the point the overridden method would normally throw an exception.

 public  void checkPropertiesAccess() 
{
        checkPermission(new PropertyPermission("*",
            SecurityConstants.PROPERTY_RW_ACTION));
}

Throws a SecurityException if the calling thread is not allowed to access or modify the system properties.

This method is used by the getProperties and setProperties methods of class System.

This method calls checkPermission with the PropertyPermission("*", "read,write") permission.

If you override this method, then you should make a call to super.checkPropertiesAccess at the point the overridden method would normally throw an exception.

 public  void checkPropertyAccess(String key) 
{
        checkPermission(new PropertyPermission(key,
            SecurityConstants.PROPERTY_READ_ACTION));
}

Throws a SecurityException if the calling thread is not allowed to access the system property with the specified key name.

This method is used by the getProperty method of class System.

This method calls checkPermission with the PropertyPermission(key, "read") permission.

If you override this method, then you should make a call to super.checkPropertyAccess at the point the overridden method would normally throw an exception.

 public  void checkRead(FileDescriptor fd) 
{
        if (fd == null) {
            throw new NullPointerException("file descriptor can't be null");
        }
        checkPermission(new RuntimePermission("readFileDescriptor"));
}

Throws a SecurityException if the calling thread is not allowed to read from the specified file descriptor.

This method calls checkPermission with the RuntimePermission("readFileDescriptor") permission.

If you override this method, then you should make a call to super.checkRead at the point the overridden method would normally throw an exception.

 public  void checkRead(String file) 
{
        checkPermission(new FilePermission(file,
            SecurityConstants.FILE_READ_ACTION));
}

Throws a SecurityException if the calling thread is not allowed to read the file specified by the string argument.

This method calls checkPermission with the FilePermission(file,"read") permission.

If you override this method, then you should make a call to super.checkRead at the point the overridden method would normally throw an exception.

 public  void checkRead(String file,
    Object context) 
{
        checkPermission(
            new FilePermission(file, SecurityConstants.FILE_READ_ACTION),
            context);
}

Throws a SecurityException if the specified security context is not allowed to read the file specified by the string argument. The context must be a security context returned by a previous call to getSecurityContext.

If context is an instance of AccessControlContext then the AccessControlContext.checkPermission method will be invoked with the FilePermission(file,"read") permission.

If context is not an instance of AccessControlContext then a SecurityException is thrown.

If you override this method, then you should make a call to super.checkRead at the point the overridden method would normally throw an exception.

 public  void checkSecurityAccess(String target) 
{
        checkPermission(new SecurityPermission(target));
}

Determines whether the permission with the specified permission target name should be granted or denied.

If the requested permission is allowed, this method returns quietly. If denied, a SecurityException is raised.

This method creates a SecurityPermission object for the given permission target name and calls checkPermission with it.

See the documentation for java.security.SecurityPermission for a list of possible permission target names.

If you override this method, then you should make a call to super.checkSecurityAccess at the point the overridden method would normally throw an exception.

 public  void checkSetFactory() 
{
        checkPermission(new RuntimePermission("setFactory"));
}

Throws a SecurityException if the calling thread is not allowed to set the socket factory used by ServerSocket or Socket, or the stream handler factory used by URL.

This method calls checkPermission with the RuntimePermission("setFactory") permission.

If you override this method, then you should make a call to super.checkSetFactory at the point the overridden method would normally throw an exception.

 public  void checkSystemClipboardAccess() 
{
        checkPermission(SecurityConstants.AWT.ACCESS_CLIPBOARD_PERMISSION);
}

Throws a SecurityException if the calling thread is not allowed to access the system clipboard.

This method calls checkPermission with the AWTPermission("accessClipboard") permission.

If you override this method, then you should make a call to super.checkSystemClipboardAccess at the point the overridden method would normally throw an exception.

 public boolean checkTopLevelWindow(Object window) 
{
        if (window == null) {
            throw new NullPointerException("window can't be null");
        }
        try {
            checkPermission(SecurityConstants.AWT.TOPLEVEL_WINDOW_PERMISSION);
            return true;
        } catch (SecurityException se) {
            // just return false
        }
        return false;
}

Returns false if the calling thread is not trusted to bring up the top-level window indicated by the window argument. In this case, the caller can still decide to show the window, but the window should include some sort of visual warning. If the method returns true, then the window can be shown without any special restrictions.

See class Window for more information on trusted and untrusted windows.

This method calls checkPermission with the AWTPermission("showWindowWithoutWarningBanner") permission, and returns true if a SecurityException is not thrown, otherwise it returns false.

If you override this method, then you should make a call to super.checkTopLevelWindow at the point the overridden method would normally return false, and the value of super.checkTopLevelWindow should be returned.

 public  void checkWrite(FileDescriptor fd) 
{
        if (fd == null) {
            throw new NullPointerException("file descriptor can't be null");
        }
        checkPermission(new RuntimePermission("writeFileDescriptor"));
}

Throws a SecurityException if the calling thread is not allowed to write to the specified file descriptor.

This method calls checkPermission with the RuntimePermission("writeFileDescriptor") permission.

If you override this method, then you should make a call to super.checkWrite at the point the overridden method would normally throw an exception.

 public  void checkWrite(String file) 
{
        checkPermission(new FilePermission(file,
            SecurityConstants.FILE_WRITE_ACTION));
}

Throws a SecurityException if the calling thread is not allowed to write to the file specified by the string argument.

This method calls checkPermission with the FilePermission(file,"write") permission.

If you override this method, then you should make a call to super.checkWrite at the point the overridden method would normally throw an exception.

 protected native int classDepth(String name)Deprecated! This -  type of security checking is not recommended.
 It is recommended that the checkPermission
 call be used instead.

Returns the stack depth of the specified class.

 protected int classLoaderDepth() 
{
        int depth = classLoaderDepth0();
        if (depth != -1) {
            if (hasAllPermission())
                depth = -1;
            else
                depth--; // make sure we don't include ourself
        }
        return depth;
}

Returns the stack depth of the most recently executing method from a class defined using a non-system class loader. A non-system class loader is defined as being a class loader that is not equal to the system class loader (as returned by ClassLoader#getSystemClassLoader ) or one of its ancestors.

This method will return -1 in the following three cases:

1. All methods on the execution stack are from classes defined using the system class loader or one of its ancestors.
2. All methods on the execution stack up to the first "privileged" caller (see java.security.AccessController#doPrivileged ) are from classes defined using the system class loader or one of its ancestors.
3. A call to checkPermission with java.security.AllPermission does not result in a SecurityException.

 protected ClassLoader currentClassLoader() 
{
        ClassLoader cl = currentClassLoader0();
        if ((cl != null) && hasAllPermission())
            cl = null;
        return cl;
}

Returns the class loader of the most recently executing method from a class defined using a non-system class loader. A non-system class loader is defined as being a class loader that is not equal to the system class loader (as returned by ClassLoader#getSystemClassLoader ) or one of its ancestors.

This method will return null in the following three cases:

1. All methods on the execution stack are from classes defined using the system class loader or one of its ancestors.
2. All methods on the execution stack up to the first "privileged" caller (see java.security.AccessController#doPrivileged ) are from classes defined using the system class loader or one of its ancestors.
3. A call to checkPermission with java.security.AllPermission does not result in a SecurityException.

 protected Class<?> currentLoadedClass() 
{
        Class c = currentLoadedClass0();
        if ((c != null) && hasAllPermission())
            c = null;
        return c;
}

Returns the class of the most recently executing method from a class defined using a non-system class loader. A non-system class loader is defined as being a class loader that is not equal to the system class loader (as returned by ClassLoader#getSystemClassLoader ) or one of its ancestors.

This method will return null in the following three cases:

1. All methods on the execution stack are from classes defined using the system class loader or one of its ancestors.
2. All methods on the execution stack up to the first "privileged" caller (see java.security.AccessController#doPrivileged ) are from classes defined using the system class loader or one of its ancestors.
3. A call to checkPermission with java.security.AllPermission does not result in a SecurityException.

 protected native Class[] getClassContext()
Returns the current execution stack as an array of classes.

The length of the array is the number of methods on the execution
stack. The element at index 0 is the class of the
currently executing method, the element at index 1 is
the class of that method's caller, and so on.

 public boolean getInCheck() 
{
        return inCheck;
}

Tests if there is a security check in progress.

 public Object getSecurityContext() 
{
        return AccessController.getContext();
}

Creates an object that encapsulates the current execution environment. The result of this method is used, for example, by the three-argument checkConnect method and by the two-argument checkRead method. These methods are needed because a trusted method may be called on to read a file or open a socket on behalf of another method. The trusted method needs to determine if the other (possibly untrusted) method would be allowed to perform the operation on its own.

The default implementation of this method is to return an AccessControlContext object.

 public ThreadGroup getThreadGroup() 
{
        return Thread.currentThread().getThreadGroup();
}

Returns the thread group into which to instantiate any new thread being created at the time this is being called. By default, it returns the thread group of the current thread. This should be overridden by a specific security manager to return the appropriate thread group.

 protected boolean inClass(String name) 
{
        return classDepth(name)  >= 0;
}

Tests if a method from a class with the specified name is on the execution stack.

 protected boolean inClassLoader() 
{
        return currentClassLoader() != null;
}

Basically, tests if a method from a class defined using a class loader is on the execution stack.