Updated samples based on latest version of code and latest java version.

[vimdoclet.git] / sample / java.lang.SecurityManager.txt

*java.lang.SecurityManager* *SecurityManager* The security manager is a class th

public class SecurityManager
  extends    |java.lang.Object|

|java.lang.SecurityManager_Description|
|java.lang.SecurityManager_Fields|
|java.lang.SecurityManager_Constructors|
|java.lang.SecurityManager_Methods|

================================================================================

*java.lang.SecurityManager_Fields*
|boolean_java.lang.SecurityManager.inCheck|

*java.lang.SecurityManager_Constructors*
|java.lang.SecurityManager()|Constructs a new SecurityManager.

*java.lang.SecurityManager_Methods*
|java.lang.SecurityManager.checkAccept(String,int)|Throws a SecurityException i
|java.lang.SecurityManager.checkAccess(Thread)|Throws a SecurityException if th
|java.lang.SecurityManager.checkAccess(ThreadGroup)|Throws a SecurityException 
|java.lang.SecurityManager.checkAwtEventQueueAccess()|Throws a SecurityExceptio
|java.lang.SecurityManager.checkConnect(String,int)|Throws a SecurityException 
|java.lang.SecurityManager.checkConnect(String,int,Object)|Throws a SecurityExc
|java.lang.SecurityManager.checkCreateClassLoader()|Throws a SecurityException 
|java.lang.SecurityManager.checkDelete(String)|Throws a SecurityException if th
|java.lang.SecurityManager.checkExec(String)|Throws a SecurityException if the 
|java.lang.SecurityManager.checkExit(int)|Throws a SecurityException if the   c
|java.lang.SecurityManager.checkLink(String)|Throws a SecurityException if the 
|java.lang.SecurityManager.checkListen(int)|Throws a SecurityException if the  
|java.lang.SecurityManager.checkMemberAccess(Class<?>,int)|Throws a SecurityExc
|java.lang.SecurityManager.checkMulticast(InetAddress)|Throws a SecurityExcepti
|java.lang.SecurityManager.checkMulticast(InetAddress,byte)|Throws a SecurityEx
|java.lang.SecurityManager.checkPackageAccess(String)|Throws a SecurityExceptio
|java.lang.SecurityManager.checkPackageDefinition(String)|Throws a SecurityExce
|java.lang.SecurityManager.checkPermission(Permission)|Throws a SecurityExcepti
|java.lang.SecurityManager.checkPermission(Permission,Object)|Throws a Security
|java.lang.SecurityManager.checkPrintJobAccess()|Throws a SecurityException if 
|java.lang.SecurityManager.checkPropertiesAccess()|Throws a SecurityException i
|java.lang.SecurityManager.checkPropertyAccess(String)|Throws a SecurityExcepti
|java.lang.SecurityManager.checkRead(FileDescriptor)|Throws a SecurityException
|java.lang.SecurityManager.checkRead(String)|Throws a SecurityException if the 
|java.lang.SecurityManager.checkRead(String,Object)|Throws a SecurityException 
|java.lang.SecurityManager.checkSecurityAccess(String)|Determines whether the p
|java.lang.SecurityManager.checkSetFactory()|Throws a SecurityException if the 
|java.lang.SecurityManager.checkSystemClipboardAccess()|Throws a SecurityExcept
|java.lang.SecurityManager.checkTopLevelWindow(Object)|Returns false if the cal
|java.lang.SecurityManager.checkWrite(FileDescriptor)|Throws a SecurityExceptio
|java.lang.SecurityManager.checkWrite(String)|Throws a SecurityException if the
|java.lang.SecurityManager.classDepth(String)|Returns the stack depth of the sp
|java.lang.SecurityManager.classLoaderDepth()|Returns the stack depth of the mo
|java.lang.SecurityManager.currentClassLoader()|Returns the class loader of the
|java.lang.SecurityManager.currentLoadedClass()|Returns the class of the most r
|java.lang.SecurityManager.getClassContext()|Returns the current execution stac
|java.lang.SecurityManager.getInCheck()|Tests if there is a security check in p
|java.lang.SecurityManager.getSecurityContext()|Creates an object that encapsul
|java.lang.SecurityManager.getThreadGroup()|Returns the thread group into which
|java.lang.SecurityManager.inClass(String)|Tests if a method from a class with 
|java.lang.SecurityManager.inClassLoader()|Basically, tests if a method from a 

*java.lang.SecurityManager_Description*

The security manager is a class that allows applications to implement a 
security policy. It allows an application to determine, before performing a 
possibly unsafe or sensitive operation, what the operation is and whether it is 
being attempted in a security context that allows the operation to be 
performed. The application can allow or disallow the operation. 

The SecurityManager class contains many methods with names that begin with the 
word check. These methods are called by various methods in the Java libraries 
before those methods perform certain potentially sensitive operations. The 
invocation of such a check method typically looks like this: 

SecurityManager security = System.getSecurityManager(); if (security != null) { 
security.checkXXX(argument, ...); } 

The security manager is thereby given an opportunity to prevent completion of 
the operation by throwing an exception. A security manager routine simply 
returns if the operation is permitted, but throws a SecurityException if the 
operation is not permitted. The only exception to this convention is 
checkTopLevelWindow, which returns a boolean value. 

The current security manager is set by the setSecurityManager method in class 
System. The current security manager is obtained by the getSecurityManager 
method. 

The special method (|java.lang.SecurityManager|) determines whether an access 
request indicated by a specified permission should be granted or denied. The 
default implementation calls 



AccessController.checkPermission(perm); 

If a requested access is allowed, checkPermission returns quietly. If denied, a 
SecurityException is thrown. 

As of Java 2 SDK v1.2, the default implementation of each of the other check 
methods in SecurityManager is to call the SecurityManager checkPermission 
method to determine if the calling thread has permission to perform the 
requested operation. 

Note that the checkPermission method with just a single permission argument 
always performs security checks within the context of the currently executing 
thread. Sometimes a security check that should be made within a given context 
will actually need to be done from within a different context (for example, 
from within a worker thread). The 
getSecurityContext(|java.lang.SecurityManager|) method and the 
checkPermission(|java.lang.SecurityManager|) method that includes a context 
argument are provided for this situation. The getSecurityContext method returns 
a "snapshot" of the current calling context. (The default implementation 
returns an AccessControlContext object.) A sample call is the following: 



Object context = null; SecurityManager sm = System.getSecurityManager(); if (sm 
!= null) context = sm.getSecurityContext(); 



The checkPermission method that takes a context object in addition to a 
permission makes access decisions based on that context, rather than on that of 
the current execution thread. Code within a different context can thus call 
that method, passing the permission and the previously-saved context object. A 
sample call, using the SecurityManager sm obtained as in the previous example, 
is the following: 



if (sm != null) sm.checkPermission(permission, context); 



Permissions fall into these categories: File, Socket, Net, Security, Runtime, 
Property, AWT, Reflect, and Serializable. The classes managing these various 
permission categories are java.io.FilePermission, java.net.SocketPermission, 
java.net.NetPermission, java.security.SecurityPermission, 
java.lang.RuntimePermission, java.util.PropertyPermission, 
java.awt.AWTPermission, java.lang.reflect.ReflectPermission, and 
java.io.SerializablePermission. 

All but the first two (FilePermission and SocketPermission) are subclasses of 
java.security.BasicPermission, which itself is an abstract subclass of the 
top-level class for permissions, which is java.security.Permission. 
BasicPermission defines the functionality needed for all permissions that 
contain a name that follows the hierarchical property naming convention (for 
example, "exitVM", "setFactory", "queuePrintJob", etc). An asterisk may appear 
at the end of the name, following a ".", or by itself, to signify a wildcard 
match. For example: "a.*" or "*" is valid, "*a" or "a*b" is not valid. 

FilePermission and SocketPermission are subclasses of the top-level class for 
permissions (java.security.Permission). Classes like these that have a more 
complicated name syntax than that used by BasicPermission subclass directly 
from Permission rather than from BasicPermission. For example, for a 
java.io.FilePermission object, the permission name is the path name of a file 
(or directory). 

Some of the permission classes have an "actions" list that tells the actions 
that are permitted for the object. For example, for a java.io.FilePermission 
object, the actions list (such as "read, write") specifies which actions are 
granted for the specified file (or for files in the specified directory). 

Other permission classes are for "named" permissions - ones that contain a name 
but no actions list; you either have the named permission or you don't. 

Note: There is also a java.security.AllPermission permission that implies all 
permissions. It exists to simplify the work of system administrators who might 
need to perform multiple tasks that require all (or numerous) permissions. 

See Permissions in the JDK for permission-related information. This document 
includes, for example, a table listing the various SecurityManager check 
methods and the permission(s) the default implementation of each such method 
requires. It also contains a table of all the version 1.2 methods that require 
permissions, and for each such method tells which permission it requires. 

For more information about SecurityManager changes made in the JDK and advice 
regarding porting of 1.1-style security managers, see the security 
documentation. 



*boolean_java.lang.SecurityManager.inCheck*

This field is true if there is a security check in progress; false otherwise. 



*java.lang.SecurityManager()*

public SecurityManager()

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. 


*java.lang.SecurityManager.checkAccept(String,int)*

public void checkAccept(
  java.lang.String host,
  int port)

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. 


    host - the host name of the socket connection. 
    port - the port number of the socket connection. 

*java.lang.SecurityManager.checkAccess(Thread)*

public void checkAccess(java.lang.Thread t)

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. 


    t - the thread to be checked. 

*java.lang.SecurityManager.checkAccess(ThreadGroup)*

public void checkAccess(java.lang.ThreadGroup g)

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. 


    g - the thread group to be checked. 

*java.lang.SecurityManager.checkAwtEventQueueAccess()*

public void checkAwtEventQueueAccess()

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. 



*java.lang.SecurityManager.checkConnect(String,int)*

public void checkConnect(
  java.lang.String host,
  int port)

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. 


    host - the host name port to connect to. 
    port - the protocol port to connect to. 

*java.lang.SecurityManager.checkConnect(String,int,Object)*

public void checkConnect(
  java.lang.String host,
  int port,
  java.lang.Object 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. 


    host - the host name port to connect to. 
    port - the protocol port to connect to. 
    context - a system-dependent security context. 

*java.lang.SecurityManager.checkCreateClassLoader()*

public void checkCreateClassLoader()

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. 



*java.lang.SecurityManager.checkDelete(String)*

public void checkDelete(java.lang.String file)

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. 


    file - the system-dependent filename. 

*java.lang.SecurityManager.checkExec(String)*

public void checkExec(java.lang.String cmd)

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. 


    cmd - the specified system command. 

*java.lang.SecurityManager.checkExit(int)*

public void checkExit(int 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. 


    status - the exit status. 

*java.lang.SecurityManager.checkLink(String)*

public void checkLink(java.lang.String 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. 


    lib - the name of the library. 

*java.lang.SecurityManager.checkListen(int)*

public void checkListen(int port)

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. 


    port - the local port. 

*java.lang.SecurityManager.checkMemberAccess(Class<?>,int)*

public void checkMemberAccess(
  java.lang.Class<?> clazz,
  int which)

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. 


    clazz - the class that reflection is to be performed on. 
    which - type of access, PUBLIC or DECLARED. 

*java.lang.SecurityManager.checkMulticast(InetAddress)*

public void checkMulticast(java.net.InetAddress maddr)

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. 


    maddr - Internet group address to be used. 

*java.lang.SecurityManager.checkMulticast(InetAddress,byte)*

public void checkMulticast(
  java.net.InetAddress maddr,
  byte ttl)

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. 

    Deprecated: Use #checkPermission(java.security.Permission) instead

    maddr - Internet group address to be used. 
    ttl - value in use, if it is multicast send. Note: this particular implementation 
       does not use the ttl parameter. 

*java.lang.SecurityManager.checkPackageAccess(String)*

public void checkPackageAccess(java.lang.String pkg)

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. 


    pkg - the package name. 

*java.lang.SecurityManager.checkPackageDefinition(String)*

public void checkPackageDefinition(java.lang.String pkg)

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. 


    pkg - the package name. 

*java.lang.SecurityManager.checkPermission(Permission)*

public void checkPermission(java.security.Permission 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. 


    perm - the requested permission. 

*java.lang.SecurityManager.checkPermission(Permission,Object)*

public void checkPermission(
  java.security.Permission perm,
  java.lang.Object context)

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. 


    perm - the specified permission 
    context - a system-dependent security context. 

*java.lang.SecurityManager.checkPrintJobAccess()*

public void checkPrintJobAccess()

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. 



*java.lang.SecurityManager.checkPropertiesAccess()*

public void checkPropertiesAccess()

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. 



*java.lang.SecurityManager.checkPropertyAccess(String)*

public void checkPropertyAccess(java.lang.String key)

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. 


    key - a system property key. 

*java.lang.SecurityManager.checkRead(FileDescriptor)*

public void checkRead(java.io.FileDescriptor fd)

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. 


    fd - the system-dependent file descriptor. 

*java.lang.SecurityManager.checkRead(String)*

public void checkRead(java.lang.String file)

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. 


    file - the system-dependent file name. 

*java.lang.SecurityManager.checkRead(String,Object)*

public void checkRead(
  java.lang.String file,
  java.lang.Object 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. 


    file - the system-dependent filename. 
    context - a system-dependent security context. 

*java.lang.SecurityManager.checkSecurityAccess(String)*

public void checkSecurityAccess(java.lang.String 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. 


    target - the target name of the SecurityPermission. 

*java.lang.SecurityManager.checkSetFactory()*

public void checkSetFactory()

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. 



*java.lang.SecurityManager.checkSystemClipboardAccess()*

public void checkSystemClipboardAccess()

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. 



*java.lang.SecurityManager.checkTopLevelWindow(Object)*

public boolean checkTopLevelWindow(java.lang.Object window)

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. 


    window - the new window that is being created. 

    Returns: true if the calling thread is trusted to put up top-level windows; false 
             otherwise. 

*java.lang.SecurityManager.checkWrite(FileDescriptor)*

public void checkWrite(java.io.FileDescriptor fd)

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. 


    fd - the system-dependent file descriptor. 

*java.lang.SecurityManager.checkWrite(String)*

public void checkWrite(java.lang.String file)

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. 


    file - the system-dependent filename. 

*java.lang.SecurityManager.classDepth(String)*

protected native int classDepth(java.lang.String name)

Returns the stack depth of the specified class. 

    Deprecated: This type of security checking is not recommended.
  It is recommended that the <code>checkPermission</code>
  call be used instead.

    name - the fully qualified name of the class to search for. 

    Returns: the depth on the stack frame of the first occurrence of a method from a class 
             with the specified name; -1 if such a frame cannot be found. 

*java.lang.SecurityManager.classLoaderDepth()*

protected int classLoaderDepth()

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 (|java.lang.ClassLoader|) ) or one of its ancestors. 

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

All methods on the execution stack are from classes defined using the system 
class loader or one of its ancestors. 

All methods on the execution stack up to the first "privileged" caller (see 
(|java.security.AccessController|) ) are from classes defined using the system 
class loader or one of its ancestors. 

A call to checkPermission with java.security.AllPermission does not result in a 
SecurityException. 



    Deprecated: This type of security checking is not recommended.
  It is recommended that the <code>checkPermission</code>
  call be used instead.


    Returns: the depth on the stack frame of the most recent occurrence of a method from a 
             class defined using a non-system class loader. 

*java.lang.SecurityManager.currentClassLoader()*

protected |java.lang.ClassLoader| currentClassLoader()

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 (|java.lang.ClassLoader|) ) or one of its ancestors. 

This method will return null in the following three cases: 

All methods on the execution stack are from classes defined using the system 
class loader or one of its ancestors. 

All methods on the execution stack up to the first "privileged" caller (see 
(|java.security.AccessController|) ) are from classes defined using the system 
class loader or one of its ancestors. 

A call to checkPermission with java.security.AllPermission does not result in a 
SecurityException. 



    Deprecated: This type of security checking is not recommended.
  It is recommended that the <code>checkPermission</code>
  call be used instead.


    Returns: the class loader of the most recent occurrence on the stack of a method from a 
             class defined using a non-system class loader. 

*java.lang.SecurityManager.currentLoadedClass()*

protected |java.lang.Class|<?> currentLoadedClass()

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 
(|java.lang.ClassLoader|) ) or one of its ancestors. 

This method will return null in the following three cases: 

All methods on the execution stack are from classes defined using the system 
class loader or one of its ancestors. 

All methods on the execution stack up to the first "privileged" caller (see 
(|java.security.AccessController|) ) are from classes defined using the system 
class loader or one of its ancestors. 

A call to checkPermission with java.security.AllPermission does not result in a 
SecurityException. 



    Deprecated: This type of security checking is not recommended.
  It is recommended that the <code>checkPermission</code>
  call be used instead.


    Returns: the class of the most recent occurrence on the stack of a method from a class 
             defined using a non-system class loader. 

*java.lang.SecurityManager.getClassContext()*

protected native |java.lang.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. 



    Returns: the execution stack. 

*java.lang.SecurityManager.getInCheck()*

public boolean getInCheck()

Tests if there is a security check in progress. 

    Deprecated: This type of security checking is not recommended.
  It is recommended that the <code>checkPermission</code>
  call be used instead.


    Returns: the value of the inCheck field. This field should contain true if a security 
             check is in progress, false otherwise. 

*java.lang.SecurityManager.getSecurityContext()*

public |java.lang.Object| getSecurityContext()

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. 



    Returns: an implementation-dependent object that encapsulates sufficient information 
             about the current execution environment to perform some security 
             checks later. 

*java.lang.SecurityManager.getThreadGroup()*

public |java.lang.ThreadGroup| 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. 



    Returns: ThreadGroup that new threads are instantiated into 

*java.lang.SecurityManager.inClass(String)*

protected boolean inClass(java.lang.String name)

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

    Deprecated: This type of security checking is not recommended.
  It is recommended that the <code>checkPermission</code>
  call be used instead.

    name - the fully qualified name of the class. 

    Returns: true if a method from a class with the specified name is on the execution 
             stack; false otherwise. 

*java.lang.SecurityManager.inClassLoader()*

protected boolean inClassLoader()

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

    Deprecated: This type of security checking is not recommended.
  It is recommended that the <code>checkPermission</code>
  call be used instead.


    Returns: true if a call to currentClassLoader has a non-null return value.