OSDN Git Service

2007-01-26 Andrew Haley <aph@redhat.com>
[pf3gnuchains/gcc-fork.git] / libjava / classpath / java / lang / SecurityManager.java
1 /* SecurityManager.java -- security checks for privileged actions
2    Copyright (C) 1998, 1999, 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
3
4 This file is part of GNU Classpath.
5
6 GNU Classpath is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GNU Classpath is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Classpath; see the file COPYING.  If not, write to the
18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301 USA.
20
21 Linking this library statically or dynamically with other modules is
22 making a combined work based on this library.  Thus, the terms and
23 conditions of the GNU General Public License cover the whole
24 combination.
25
26 As a special exception, the copyright holders of this library give you
27 permission to link this library with independent modules to produce an
28 executable, regardless of the license terms of these independent
29 modules, and to copy and distribute the resulting executable under
30 terms of your choice, provided that you also meet, for each linked
31 independent module, the terms and conditions of the license of that
32 module.  An independent module is a module which is not derived from
33 or based on this library.  If you modify this library, you may extend
34 this exception to your version of the library, but you are not
35 obligated to do so.  If you do not wish to do so, delete this
36 exception statement from your version. */
37
38
39 package java.lang;
40
41 import gnu.classpath.VMStackWalker;
42
43 import java.awt.AWTPermission;
44 import java.io.File;
45 import java.io.FileDescriptor;
46 import java.io.FileInputStream;
47 import java.io.FileOutputStream;
48 import java.io.FilePermission;
49 import java.io.RandomAccessFile;
50 import java.lang.reflect.Member;
51 import java.net.InetAddress;
52 import java.net.ServerSocket;
53 import java.net.Socket;
54 import java.net.SocketImplFactory;
55 import java.net.SocketPermission;
56 import java.net.URL;
57 import java.net.URLStreamHandlerFactory;
58 import java.security.AccessControlContext;
59 import java.security.AccessControlException;
60 import java.security.AccessController;
61 import java.security.AllPermission;
62 import java.security.BasicPermission;
63 import java.security.Permission;
64 import java.security.Policy;
65 import java.security.PrivilegedAction;
66 import java.security.ProtectionDomain;
67 import java.security.Security;
68 import java.security.SecurityPermission;
69 import java.util.Properties;
70 import java.util.PropertyPermission;
71 import java.util.StringTokenizer;
72
73 /**
74  * SecurityManager is a class you can extend to create your own Java
75  * security policy.  By default, there is no SecurityManager installed in
76  * 1.1, which means that all things are permitted to all people. The security
77  * manager, if set, is consulted before doing anything with potentially
78  * dangerous results, and throws a <code>SecurityException</code> if the
79  * action is forbidden.
80  *
81  * <p>A typical check is as follows, just before the dangerous operation:<br>
82  * <pre>
83  * SecurityManager sm = System.getSecurityManager();
84  * if (sm != null)
85  *   sm.checkABC(<em>argument</em>, ...);
86  * </pre>
87  * Note that this is thread-safe, by caching the security manager in a local
88  * variable rather than risking a NullPointerException if the mangager is
89  * changed between the check for null and before the permission check.
90  *
91  * <p>The special method <code>checkPermission</code> is a catchall, and
92  * the default implementation calls
93  * <code>AccessController.checkPermission</code>. In fact, all the other
94  * methods default to calling checkPermission.
95  *
96  * <p>Sometimes, the security check needs to happen from a different context,
97  * such as when called from a worker thread. In such cases, use
98  * <code>getSecurityContext</code> to take a snapshot that can be passed
99  * to the worker thread:<br>
100  * <pre>
101  * Object context = null;
102  * SecurityManager sm = System.getSecurityManager();
103  * if (sm != null)
104  *   context = sm.getSecurityContext(); // defaults to an AccessControlContext
105  * // now, in worker thread
106  * if (sm != null)
107  *   sm.checkPermission(permission, context);
108  * </pre>
109  *
110  * <p>Permissions fall into these categories: File, Socket, Net, Security,
111  * Runtime, Property, AWT, Reflect, and Serializable. Each of these
112  * permissions have a property naming convention, that follows a hierarchical
113  * naming convention, to make it easy to grant or deny several permissions
114  * at once. Some permissions also take a list of permitted actions, such
115  * as "read" or "write", to fine-tune control even more. The permission
116  * <code>java.security.AllPermission</code> grants all permissions.
117  *
118  * <p>The default methods in this class deny all things to all people. You
119  * must explicitly grant permission for anything you want to be legal when
120  * subclassing this class.
121  *
122  * @author John Keiser
123  * @author Eric Blake (ebb9@email.byu.edu)
124  * @see ClassLoader
125  * @see SecurityException
126  * @see #checkTopLevelWindow(Object)
127  * @see System#getSecurityManager()
128  * @see System#setSecurityManager(SecurityManager)
129  * @see AccessController
130  * @see AccessControlContext
131  * @see AccessControlException
132  * @see Permission
133  * @see BasicPermission
134  * @see java.io.FilePermission
135  * @see java.net.SocketPermission
136  * @see java.util.PropertyPermission
137  * @see RuntimePermission
138  * @see java.awt.AWTPermission
139  * @see Policy
140  * @see SecurityPermission
141  * @see ProtectionDomain
142  * @since 1.0
143  * @status still missing 1.4 functionality
144  */
145 public class SecurityManager
146 {
147   /**
148    * The current security manager. This is located here instead of in
149    * System, to avoid security problems, as well as bootstrap issues.
150    * Make sure to access it in a thread-safe manner; it is package visible
151    * to avoid overhead in java.lang.
152    */
153   static volatile SecurityManager current;
154
155   /**
156    * Tells whether or not the SecurityManager is currently performing a
157    * security check.
158    * @deprecated Use {@link #checkPermission(Permission)} instead.
159    */
160   protected boolean inCheck;
161
162   /**
163    * Construct a new security manager. There may be a security check, of
164    * <code>RuntimePermission("createSecurityManager")</code>.
165    *
166    * @throws SecurityException if permission is denied
167    */
168   public SecurityManager()
169   {
170     /* "When there is security manager installed, the security manager
171        need to check the package access. However, if the security
172        manager itself uses any unloaded class, it will trigger the
173        classloading, which causes infinite loop. There is no easy
174        legal solution. The workaround will be that security manager
175        can not depend on any unloaded class. In the constructor of
176        security manager, it must transitively load all classes it
177        refers to."  Sun bug #4242924.  */
178
179     // Load and initialize java.security.Security
180     java.security.Security.getProvider((String)null);
181
182     SecurityManager sm = System.getSecurityManager();
183     if (sm != null)
184       sm.checkPermission(new RuntimePermission("createSecurityManager"));
185   }
186
187   /**
188    * Tells whether or not the SecurityManager is currently performing a
189    * security check.
190    *
191    * @return true if the SecurityManager is in a security check
192    * @see #inCheck
193    * @deprecated use {@link #checkPermission(Permission)} instead
194    */
195   public boolean getInCheck()
196   {
197     return inCheck;
198   }
199
200   /**
201    * Get a list of all the classes currently executing methods on the Java
202    * stack.  getClassContext()[0] is the currently executing method (ie. the
203    * class that CALLED getClassContext, not SecurityManager).
204    *
205    * @return an array of classes on the Java execution stack
206    */
207   protected Class[] getClassContext()
208   {
209     Class[] stack1 = VMStackWalker.getClassContext();
210     Class[] stack2 = new Class[stack1.length - 1];
211     System.arraycopy(stack1, 1, stack2, 0, stack1.length - 1);
212     return stack2;
213   }
214
215   /**
216    * Find the ClassLoader of the first non-system class on the execution
217    * stack. A non-system class is one whose ClassLoader is not equal to
218    * {@link ClassLoader#getSystemClassLoader()} or its ancestors. This
219    * will return null in three cases:
220    *
221    * <ul>
222    * <li>All methods on the stack are from system classes</li>
223    * <li>All methods on the stack up to the first "privileged" caller, as
224    *  created by {@link AccessController#doPrivileged(PrivilegedAction)},
225    *  are from system classes</li>
226    * <li>A check of <code>java.security.AllPermission</code> succeeds.</li>
227    * </ul>
228    * 
229    * @return the most recent non-system ClassLoader on the execution stack
230    * @deprecated use {@link #checkPermission(Permission)} instead
231    */
232   protected ClassLoader currentClassLoader()
233   {
234     Class cl = currentLoadedClass();
235     return cl != null ? cl.getClassLoader() : null;
236   }
237
238   /**
239    * Find the first non-system class on the execution stack. A non-system
240    * class is one whose ClassLoader is not equal to
241    * {@link ClassLoader#getSystemClassLoader()} or its ancestors. This
242    * will return null in three cases:
243    *
244    * <ul>
245    * <li>All methods on the stack are from system classes</li>
246    * <li>All methods on the stack up to the first "privileged" caller, as
247    *  created by {@link AccessController#doPrivileged(PrivilegedAction)},
248    *  are from system classes</li>
249    * <li>A check of <code>java.security.AllPermission</code> succeeds.</li>
250    * </ul>
251    * 
252    * @return the most recent non-system Class on the execution stack
253    * @deprecated use {@link #checkPermission(Permission)} instead
254    */
255   protected Class<?> currentLoadedClass()
256   {
257     int i = classLoaderDepth();
258     return i >= 0 ? getClassContext()[i] : null;
259   }
260
261   /**
262    * Get the depth of a particular class on the execution stack.
263    *
264    * @param className the fully-qualified name to search for
265    * @return the index of the class on the stack, or -1
266    * @deprecated use {@link #checkPermission(Permission)} instead
267    */
268   protected int classDepth(String className)
269   {
270     Class[] c = getClassContext();
271     for (int i = 0; i < c.length; i++)
272       if (className.equals(c[i].getName()))
273         return i;
274     return -1;
275   }
276
277   /**
278    * Get the depth on the execution stack of the most recent non-system class.
279    * A non-system class is one whose ClassLoader is not equal to
280    * {@link ClassLoader#getSystemClassLoader()} or its ancestors. This
281    * will return -1 in three cases:
282    *
283    * <ul>
284    * <li>All methods on the stack are from system classes</li>
285    * <li>All methods on the stack up to the first "privileged" caller, as
286    *  created by {@link AccessController#doPrivileged(PrivilegedAction)},
287    *  are from system classes</li>
288    * <li>A check of <code>java.security.AllPermission</code> succeeds.</li>
289    * </ul>
290    * 
291    * @return the index of the most recent non-system Class on the stack
292    * @deprecated use {@link #checkPermission(Permission)} instead
293    */
294   protected int classLoaderDepth()
295   {
296     try
297       {
298         checkPermission(new AllPermission());
299       }
300     catch (SecurityException e)
301       {
302         Class[] c = getClassContext();
303         for (int i = 0; i < c.length; i++)
304           if (c[i].getClassLoader() != null)
305             // XXX Check if c[i] is AccessController, or a system class.
306             return i;
307       }
308     return -1;
309   }
310
311   /**
312    * Tell whether the specified class is on the execution stack.
313    *
314    * @param className the fully-qualified name of the class to find
315    * @return whether the specified class is on the execution stack
316    * @deprecated use {@link #checkPermission(Permission)} instead
317    */
318   protected boolean inClass(String className)
319   {
320     return classDepth(className) != -1;
321   }
322
323   /**
324    * Tell whether there is a class loaded with an explicit ClassLoader on
325    * the stack.
326    *
327    * @return whether a class with an explicit ClassLoader is on the stack
328    * @deprecated use {@link #checkPermission(Permission)} instead
329    */
330   protected boolean inClassLoader()
331   {
332     return classLoaderDepth() != -1;
333   }
334
335   /**
336    * Get an implementation-dependent Object that contains enough information
337    * about the current environment to be able to perform standard security
338    * checks later.  This is used by trusted methods that need to verify that
339    * their callers have sufficient access to perform certain operations.
340    *
341    * <p>Currently the only methods that use this are checkRead() and
342    * checkConnect(). The default implementation returns an
343    * <code>AccessControlContext</code>.
344    *
345    * @return a security context
346    * @see #checkConnect(String, int, Object)
347    * @see #checkRead(String, Object)
348    * @see AccessControlContext
349    * @see AccessController#getContext()
350    */
351   public Object getSecurityContext()
352   {
353     return AccessController.getContext();
354   }
355
356   /**
357    * Check if the current thread is allowed to perform an operation that
358    * requires the specified <code>Permission</code>. This defaults to
359    * <code>AccessController.checkPermission</code>.
360    *
361    * @param perm the <code>Permission</code> required
362    * @throws SecurityException if permission is denied
363    * @throws NullPointerException if perm is null
364    * @since 1.2
365    */
366   public void checkPermission(Permission perm)
367   {
368     AccessController.checkPermission(perm);
369   }
370
371   /**
372    * Check if the current thread is allowed to perform an operation that
373    * requires the specified <code>Permission</code>. This is done in a
374    * context previously returned by <code>getSecurityContext()</code>. The
375    * default implementation expects context to be an AccessControlContext,
376    * and it calls <code>AccessControlContext.checkPermission(perm)</code>.
377    *
378    * @param perm the <code>Permission</code> required
379    * @param context a security context
380    * @throws SecurityException if permission is denied, or if context is
381    *         not an AccessControlContext
382    * @throws NullPointerException if perm is null
383    * @see #getSecurityContext()
384    * @see AccessControlContext#checkPermission(Permission)
385    * @since 1.2
386    */
387   public void checkPermission(Permission perm, Object context)
388   {
389     if (! (context instanceof AccessControlContext))
390       throw new SecurityException("Missing context");
391     ((AccessControlContext) context).checkPermission(perm);
392   }
393
394   /**
395    * Check if the current thread is allowed to create a ClassLoader. This
396    * method is called from ClassLoader.ClassLoader(), and checks
397    * <code>RuntimePermission("createClassLoader")</code>. If you override
398    * this, you should call <code>super.checkCreateClassLoader()</code> rather
399    * than throwing an exception.
400    *
401    * @throws SecurityException if permission is denied
402    * @see ClassLoader#ClassLoader()
403    */
404   public void checkCreateClassLoader()
405   {
406     checkPermission(new RuntimePermission("createClassLoader"));
407   }
408
409   /**
410    * Check if the current thread is allowed to modify another Thread. This is
411    * called by Thread.stop(), suspend(), resume(), interrupt(), destroy(),
412    * setPriority(), setName(), and setDaemon(). The default implementation
413    * checks <code>RuntimePermission("modifyThread")</code> on system threads
414    * (ie. threads in ThreadGroup with a null parent), and returns silently on
415    * other threads.
416    *
417    * <p>If you override this, you must do two things. First, call
418    * <code>super.checkAccess(t)</code>, to make sure you are not relaxing
419    * requirements. Second, if the calling thread has
420    * <code>RuntimePermission("modifyThread")</code>, return silently, so that
421    * core classes (the Classpath library!) can modify any thread.
422    *
423    * @param thread the other Thread to check
424    * @throws SecurityException if permission is denied
425    * @throws NullPointerException if thread is null
426    * @see Thread#stop()
427    * @see Thread#suspend()
428    * @see Thread#resume()
429    * @see Thread#setPriority(int)
430    * @see Thread#setName(String)
431    * @see Thread#setDaemon(boolean)
432    */
433   public void checkAccess(Thread thread)
434   {
435     if (thread.getThreadGroup() != null 
436         && thread.getThreadGroup().parent == null)
437       checkPermission(new RuntimePermission("modifyThread"));
438   }
439
440   /**
441    * Check if the current thread is allowed to modify a ThreadGroup. This is
442    * called by Thread.Thread() (to add a thread to the ThreadGroup),
443    * ThreadGroup.ThreadGroup() (to add this ThreadGroup to a parent),
444    * ThreadGroup.stop(), suspend(), resume(), interrupt(), destroy(),
445    * setDaemon(), and setMaxPriority(). The default implementation
446    * checks <code>RuntimePermission("modifyThread")</code> on the system group
447    * (ie. the one with a null parent), and returns silently on other groups.
448    *
449    * <p>If you override this, you must do two things. First, call
450    * <code>super.checkAccess(t)</code>, to make sure you are not relaxing
451    * requirements. Second, if the calling thread has
452    * <code>RuntimePermission("modifyThreadGroup")</code>, return silently,
453    * so that core classes (the Classpath library!) can modify any thread.
454    *
455    * @param g the ThreadGroup to check
456    * @throws SecurityException if permission is denied
457    * @throws NullPointerException if g is null
458    * @see Thread#Thread()
459    * @see ThreadGroup#ThreadGroup(String)
460    * @see ThreadGroup#stop()
461    * @see ThreadGroup#suspend()
462    * @see ThreadGroup#resume()
463    * @see ThreadGroup#interrupt()
464    * @see ThreadGroup#setDaemon(boolean)
465    * @see ThreadGroup#setMaxPriority(int)
466    */
467   public void checkAccess(ThreadGroup g)
468   {
469     if (g.parent == null)
470       checkPermission(new RuntimePermission("modifyThreadGroup"));
471   }
472
473   /**
474    * Check if the current thread is allowed to exit the JVM with the given
475    * status. This method is called from Runtime.exit() and Runtime.halt().
476    * The default implementation checks
477    * <code>RuntimePermission("exitVM")</code>. If you override this, call
478    * <code>super.checkExit</code> rather than throwing an exception.
479    *
480    * @param status the status to exit with
481    * @throws SecurityException if permission is denied
482    * @see Runtime#exit(int)
483    * @see Runtime#halt(int)
484    */
485   public void checkExit(int status)
486   {
487     checkPermission(new RuntimePermission("exitVM"));
488   }
489
490   /**
491    * Check if the current thread is allowed to execute the given program. This
492    * method is called from Runtime.exec(). If the name is an absolute path,
493    * the default implementation checks
494    * <code>FilePermission(program, "execute")</code>, otherwise it checks
495    * <code>FilePermission("&lt;&lt;ALL FILES&gt;&gt;", "execute")</code>. If
496    * you override this, call <code>super.checkExec</code> rather than
497    * throwing an exception.
498    *
499    * @param program the name of the program to exec
500    * @throws SecurityException if permission is denied
501    * @throws NullPointerException if program is null
502    * @see Runtime#exec(String[], String[], File)
503    */
504   public void checkExec(String program)
505   {
506     if (! program.equals(new File(program).getAbsolutePath()))
507       program = "<<ALL FILES>>";
508     checkPermission(new FilePermission(program, "execute"));
509   }
510
511   /**
512    * Check if the current thread is allowed to link in the given native
513    * library. This method is called from Runtime.load() (and hence, by
514    * loadLibrary() as well). The default implementation checks
515    * <code>RuntimePermission("loadLibrary." + filename)</code>. If you
516    * override this, call <code>super.checkLink</code> rather than throwing
517    * an exception.
518    *
519    * @param filename the full name of the library to load
520    * @throws SecurityException if permission is denied
521    * @throws NullPointerException if filename is null
522    * @see Runtime#load(String)
523    */
524   public void checkLink(String filename)
525   {
526     // Use the toString() hack to do the null check.
527     checkPermission(new RuntimePermission("loadLibrary."
528                                           + filename.toString()));
529   }
530
531   /**
532    * Check if the current thread is allowed to read the given file using the
533    * FileDescriptor. This method is called from
534    * FileInputStream.FileInputStream(). The default implementation checks
535    * <code>RuntimePermission("readFileDescriptor")</code>. If you override
536    * this, call <code>super.checkRead</code> rather than throwing an
537    * exception.
538    *
539    * @param desc the FileDescriptor representing the file to access
540    * @throws SecurityException if permission is denied
541    * @throws NullPointerException if desc is null
542    * @see FileInputStream#FileInputStream(FileDescriptor)
543    */
544   public void checkRead(FileDescriptor desc)
545   {
546     if (desc == null)
547       throw new NullPointerException();
548     checkPermission(new RuntimePermission("readFileDescriptor"));
549   }
550
551   /**
552    * Check if the current thread is allowed to read the given file. This
553    * method is called from FileInputStream.FileInputStream(),
554    * RandomAccessFile.RandomAccessFile(), File.exists(), canRead(), isFile(),
555    * isDirectory(), lastModified(), length() and list(). The default
556    * implementation checks <code>FilePermission(filename, "read")</code>. If
557    * you override this, call <code>super.checkRead</code> rather than
558    * throwing an exception.
559    *
560    * @param filename the full name of the file to access
561    * @throws SecurityException if permission is denied
562    * @throws NullPointerException if filename is null
563    * @see File
564    * @see FileInputStream#FileInputStream(String)
565    * @see RandomAccessFile#RandomAccessFile(String, String)
566    */
567   public void checkRead(String filename)
568   {
569     checkPermission(new FilePermission(filename, "read"));
570   }
571
572   /**
573    * Check if the current thread is allowed to read the given file. using the
574    * given security context. The context must be a result of a previous call
575    * to <code>getSecurityContext()</code>. The default implementation checks
576    * <code>AccessControlContext.checkPermission(new FilePermission(filename,
577    * "read"))</code>. If you override this, call <code>super.checkRead</code>
578    * rather than throwing an exception.
579    *
580    * @param filename the full name of the file to access
581    * @param context the context to determine access for
582    * @throws SecurityException if permission is denied, or if context is
583    *         not an AccessControlContext
584    * @throws NullPointerException if filename is null
585    * @see #getSecurityContext()
586    * @see AccessControlContext#checkPermission(Permission)
587    */
588   public void checkRead(String filename, Object context)
589   {
590     if (! (context instanceof AccessControlContext))
591       throw new SecurityException("Missing context");
592     AccessControlContext ac = (AccessControlContext) context;
593     ac.checkPermission(new FilePermission(filename, "read"));
594   }
595
596   /**
597    * Check if the current thread is allowed to write the given file using the
598    * FileDescriptor. This method is called from
599    * FileOutputStream.FileOutputStream(). The default implementation checks
600    * <code>RuntimePermission("writeFileDescriptor")</code>. If you override
601    * this, call <code>super.checkWrite</code> rather than throwing an
602    * exception.
603    *
604    * @param desc the FileDescriptor representing the file to access
605    * @throws SecurityException if permission is denied
606    * @throws NullPointerException if desc is null
607    * @see FileOutputStream#FileOutputStream(FileDescriptor)
608    */
609   public void checkWrite(FileDescriptor desc)
610   {
611     if (desc == null)
612       throw new NullPointerException();
613     checkPermission(new RuntimePermission("writeFileDescriptor"));
614   }
615
616   /**
617    * Check if the current thread is allowed to write the given file. This
618    * method is called from FileOutputStream.FileOutputStream(),
619    * RandomAccessFile.RandomAccessFile(), File.canWrite(), mkdir(), and
620    * renameTo(). The default implementation checks
621    * <code>FilePermission(filename, "write")</code>. If you override this,
622    * call <code>super.checkWrite</code> rather than throwing an exception.
623    *
624    * @param filename the full name of the file to access
625    * @throws SecurityException if permission is denied
626    * @throws NullPointerException if filename is null
627    * @see File
628    * @see File#canWrite()
629    * @see File#mkdir()
630    * @see File#renameTo(File)
631    * @see FileOutputStream#FileOutputStream(String)
632    * @see RandomAccessFile#RandomAccessFile(String, String)
633    */
634   public void checkWrite(String filename)
635   {
636     checkPermission(new FilePermission(filename, "write"));
637   }
638
639   /**
640    * Check if the current thread is allowed to delete the given file. This
641    * method is called from File.delete(). The default implementation checks
642    * <code>FilePermission(filename, "delete")</code>. If you override this,
643    * call <code>super.checkDelete</code> rather than throwing an exception.
644    *
645    * @param filename the full name of the file to delete
646    * @throws SecurityException if permission is denied
647    * @throws NullPointerException if filename is null
648    * @see File#delete()
649    */
650   public void checkDelete(String filename)
651   {
652     checkPermission(new FilePermission(filename, "delete"));
653   }
654
655   /**
656    * Check if the current thread is allowed to connect to a given host on a
657    * given port. This method is called from Socket.Socket(). A port number
658    * of -1 indicates the caller is attempting to determine an IP address, so
659    * the default implementation checks
660    * <code>SocketPermission(host, "resolve")</code>. Otherwise, the default
661    * implementation checks
662    * <code>SocketPermission(host + ":" + port, "connect")</code>. If you
663    * override this, call <code>super.checkConnect</code> rather than throwing
664    * an exception.
665    *
666    * @param host the host to connect to
667    * @param port the port to connect on
668    * @throws SecurityException if permission is denied
669    * @throws NullPointerException if host is null
670    * @see Socket#Socket()
671    */
672   public void checkConnect(String host, int port)
673   {
674     if (port == -1)
675       checkPermission(new SocketPermission(host, "resolve"));
676     else
677       // Use the toString() hack to do the null check.
678       checkPermission(new SocketPermission(host.toString() + ":" + port,
679                                            "connect"));
680   }
681
682   /**
683    * Check if the current thread is allowed to connect to a given host on a
684    * given port, using the given security context. The context must be a
685    * result of a previous call to <code>getSecurityContext</code>. A port
686    * number of -1 indicates the caller is attempting to determine an IP
687    * address, so the default implementation checks
688    * <code>AccessControlContext.checkPermission(new SocketPermission(host,
689    * "resolve"))</code>. Otherwise, the default implementation checks
690    * <code>AccessControlContext.checkPermission(new SocketPermission(host
691    * + ":" + port, "connect"))</code>. If you override this, call
692    * <code>super.checkConnect</code> rather than throwing an exception.
693    *
694    * @param host the host to connect to
695    * @param port the port to connect on
696    * @param context the context to determine access for
697    *
698    * @throws SecurityException if permission is denied, or if context is
699    *         not an AccessControlContext
700    * @throws NullPointerException if host is null
701    *
702    * @see #getSecurityContext()
703    * @see AccessControlContext#checkPermission(Permission)
704    */
705   public void checkConnect(String host, int port, Object context)
706   {
707     if (! (context instanceof AccessControlContext))
708       throw new SecurityException("Missing context");
709     AccessControlContext ac = (AccessControlContext) context;
710     if (port == -1)
711       ac.checkPermission(new SocketPermission(host, "resolve"));
712     else
713       // Use the toString() hack to do the null check.
714       ac.checkPermission(new SocketPermission(host.toString() + ":" + port,
715                                               "connect"));
716   }
717
718   /**
719    * Check if the current thread is allowed to listen to a specific port for
720    * data. This method is called by ServerSocket.ServerSocket(). The default
721    * implementation checks
722    * <code>SocketPermission("localhost:" + (port == 0 ? "1024-" : "" + port),
723    * "listen")</code>. If you override this, call
724    * <code>super.checkListen</code> rather than throwing an exception.
725    *
726    * @param port the port to listen on
727    * @throws SecurityException if permission is denied
728    * @see ServerSocket#ServerSocket(int)
729    */
730   public void checkListen(int port)
731   {
732     checkPermission(new SocketPermission("localhost:"
733                                          + (port == 0 ? "1024-" : "" +port),
734                                          "listen"));
735   }
736
737   /**
738    * Check if the current thread is allowed to accept a connection from a
739    * particular host on a particular port. This method is called by
740    * ServerSocket.implAccept(). The default implementation checks
741    * <code>SocketPermission(host + ":" + port, "accept")</code>. If you
742    * override this, call <code>super.checkAccept</code> rather than throwing
743    * an exception.
744    *
745    * @param host the host which wishes to connect
746    * @param port the port the connection will be on
747    * @throws SecurityException if permission is denied
748    * @throws NullPointerException if host is null
749    * @see ServerSocket#accept()
750    */
751   public void checkAccept(String host, int port)
752   {
753     // Use the toString() hack to do the null check.
754     checkPermission(new SocketPermission(host.toString() + ":" + port,
755                                          "accept"));
756   }
757
758   /**
759    * Check if the current thread is allowed to read and write multicast to
760    * a particular address. The default implementation checks
761    * <code>SocketPermission(addr.getHostAddress(), "accept,connect")</code>.
762    * If you override this, call <code>super.checkMulticast</code> rather than
763    * throwing an exception.
764    *
765    * @param addr the address to multicast to
766    * @throws SecurityException if permission is denied
767    * @throws NullPointerException if host is null
768    * @since 1.1
769    */
770   public void checkMulticast(InetAddress addr)
771   {
772     checkPermission(new SocketPermission(addr.getHostAddress(),
773                                          "accept,connect"));
774   }
775
776   /**
777    *Check if the current thread is allowed to read and write multicast to
778    * a particular address with a particular ttl (time-to-live) value. The
779    * default implementation ignores ttl, and checks
780    * <code>SocketPermission(addr.getHostAddress(), "accept,connect")</code>.
781    * If you override this, call <code>super.checkMulticast</code> rather than
782    * throwing an exception.
783    *
784    * @param addr the address to multicast to
785    * @param ttl value in use for multicast send
786    * @throws SecurityException if permission is denied
787    * @throws NullPointerException if host is null
788    * @since 1.1
789    * @deprecated use {@link #checkPermission(Permission)} instead
790    */
791   public void checkMulticast(InetAddress addr, byte ttl)
792   {
793     checkPermission(new SocketPermission(addr.getHostAddress(),
794                                          "accept,connect"));
795   }
796
797   /**
798    * Check if the current thread is allowed to read or write all the system
799    * properties at once. This method is called by System.getProperties()
800    * and setProperties(). The default implementation checks
801    * <code>PropertyPermission("*", "read,write")</code>. If you override
802    * this, call <code>super.checkPropertiesAccess</code> rather than
803    * throwing an exception.
804    *
805    * @throws SecurityException if permission is denied
806    * @see System#getProperties()
807    * @see System#setProperties(Properties)
808    */
809   public void checkPropertiesAccess()
810   {
811     checkPermission(new PropertyPermission("*", "read,write"));
812   }
813
814   /**
815    * Check if the current thread is allowed to read a particular system
816    * property (writes are checked directly via checkPermission). This method
817    * is called by System.getProperty() and setProperty(). The default
818    * implementation checks <code>PropertyPermission(key, "read")</code>. If
819    * you override this, call <code>super.checkPropertyAccess</code> rather
820    * than throwing an exception.
821    *
822    * @param key the key of the property to check
823    *
824    * @throws SecurityException if permission is denied
825    * @throws NullPointerException if key is null
826    * @throws IllegalArgumentException if key is ""
827    *
828    * @see System#getProperty(String)
829    */
830   public void checkPropertyAccess(String key)
831   {
832     checkPermission(new PropertyPermission(key, "read"));
833   }
834
835   /**
836    * Check if the current thread is allowed to create a top-level window. If
837    * it is not, the operation should still go through, but some sort of
838    * nonremovable warning should be placed on the window to show that it
839    * is untrusted. This method is called by Window.Window(). The default
840    * implementation checks
841    * <code>AWTPermission("showWindowWithoutWarningBanner")</code>, and returns
842    * true if no exception was thrown. If you override this, use
843    * <code>return super.checkTopLevelWindow</code> rather than returning
844    * false.
845    *
846    * @param window the window to create
847    * @return true if there is permission to show the window without warning
848    * @throws NullPointerException if window is null
849    * @see java.awt.Window#Window(java.awt.Frame)
850    */
851   public boolean checkTopLevelWindow(Object window)
852   {
853     if (window == null)
854       throw new NullPointerException();
855     try
856       {
857         checkPermission(new AWTPermission("showWindowWithoutWarningBanner"));
858         return true;
859       }
860     catch (SecurityException e)
861       {
862         return false;
863       }
864   }
865
866   /**
867    * Check if the current thread is allowed to create a print job. This
868    * method is called by Toolkit.getPrintJob(). The default implementation
869    * checks <code>RuntimePermission("queuePrintJob")</code>. If you override
870    * this, call <code>super.checkPrintJobAccess</code> rather than throwing
871    * an exception.
872    *
873    * @throws SecurityException if permission is denied
874    * @see java.awt.Toolkit#getPrintJob(java.awt.Frame, String, Properties)
875    * @since 1.1
876    */
877   public void checkPrintJobAccess()
878   {
879     checkPermission(new RuntimePermission("queuePrintJob"));
880   }
881
882   /**
883    * Check if the current thread is allowed to use the system clipboard. This
884    * method is called by Toolkit.getSystemClipboard(). The default
885    * implementation checks <code>AWTPermission("accessClipboard")</code>. If
886    * you override this, call <code>super.checkSystemClipboardAccess</code>
887    * rather than throwing an exception.
888    *
889    * @throws SecurityException if permission is denied
890    * @see java.awt.Toolkit#getSystemClipboard()
891    * @since 1.1
892    */
893   public void checkSystemClipboardAccess()
894   {
895     checkPermission(new AWTPermission("accessClipboard"));
896   }
897
898   /**
899    * Check if the current thread is allowed to use the AWT event queue. This
900    * method is called by Toolkit.getSystemEventQueue(). The default
901    * implementation checks <code>AWTPermission("accessEventQueue")</code>.
902    * you override this, call <code>super.checkAwtEventQueueAccess</code>
903    * rather than throwing an exception.
904    *
905    * @throws SecurityException if permission is denied
906    * @see java.awt.Toolkit#getSystemEventQueue()
907    * @since 1.1
908    */
909   public void checkAwtEventQueueAccess()
910   {
911     checkPermission(new AWTPermission("accessEventQueue"));
912   }
913
914   /**
915    * Check if the current thread is allowed to access the specified package
916    * at all. This method is called by ClassLoader.loadClass() in user-created
917    * ClassLoaders. The default implementation gets a list of all restricted
918    * packages, via <code>Security.getProperty("package.access")</code>. Then,
919    * if packageName starts with or equals any restricted package, it checks
920    * <code>RuntimePermission("accessClassInPackage." + packageName)</code>.
921    * If you override this, you should call
922    * <code>super.checkPackageAccess</code> before doing anything else.
923    *
924    * @param packageName the package name to check access to
925    * @throws SecurityException if permission is denied
926    * @throws NullPointerException if packageName is null
927    * @see ClassLoader#loadClass(String, boolean)
928    * @see Security#getProperty(String)
929    */
930   public void checkPackageAccess(String packageName)
931   {
932     checkPackageList(packageName, "package.access", "accessClassInPackage.");
933   }
934
935   /**
936    * Check if the current thread is allowed to define a class into the
937    * specified package. This method is called by ClassLoader.loadClass() in
938    * user-created ClassLoaders. The default implementation gets a list of all
939    * restricted packages, via
940    * <code>Security.getProperty("package.definition")</code>. Then, if
941    * packageName starts with or equals any restricted package, it checks
942    * <code>RuntimePermission("defineClassInPackage." + packageName)</code>.
943    * If you override this, you should call
944    * <code>super.checkPackageDefinition</code> before doing anything else.
945    *
946    * @param packageName the package name to check access to
947    * @throws SecurityException if permission is denied
948    * @throws NullPointerException if packageName is null
949    * @see ClassLoader#loadClass(String, boolean)
950    * @see Security#getProperty(String)
951    */
952   public void checkPackageDefinition(String packageName)
953   {
954     checkPackageList(packageName, "package.definition", "defineClassInPackage.");
955   }
956
957   /**
958    * Check if the current thread is allowed to set the current socket factory.
959    * This method is called by Socket.setSocketImplFactory(),
960    * ServerSocket.setSocketFactory(), and URL.setURLStreamHandlerFactory().
961    * The default implementation checks
962    * <code>RuntimePermission("setFactory")</code>. If you override this, call
963    * <code>super.checkSetFactory</code> rather than throwing an exception.
964    *
965    * @throws SecurityException if permission is denied
966    * @see Socket#setSocketImplFactory(SocketImplFactory)
967    * @see ServerSocket#setSocketFactory(SocketImplFactory)
968    * @see URL#setURLStreamHandlerFactory(URLStreamHandlerFactory)
969    */
970   public void checkSetFactory()
971   {
972     checkPermission(new RuntimePermission("setFactory"));
973   }
974
975   /**
976    * Check if the current thread is allowed to get certain types of Methods,
977    * Fields and Constructors from a Class object. This method is called by
978    * Class.getMethod[s](), Class.getField[s](), Class.getConstructor[s],
979    * Class.getDeclaredMethod[s](), Class.getDeclaredField[s](), and
980    * Class.getDeclaredConstructor[s](). The default implementation allows
981    * PUBLIC access, and access to classes defined by the same classloader as
982    * the code performing the reflection. Otherwise, it checks
983    * <code>RuntimePermission("accessDeclaredMembers")</code>. If you override
984    * this, do not call <code>super.checkMemberAccess</code>, as this would
985    * mess up the stack depth check that determines the ClassLoader requesting
986    * the access.
987    *
988    * @param c the Class to check
989    * @param memberType either DECLARED or PUBLIC
990    * @throws SecurityException if permission is denied, including when
991    *         memberType is not DECLARED or PUBLIC
992    * @throws NullPointerException if c is null
993    * @see Class
994    * @see Member#DECLARED
995    * @see Member#PUBLIC
996    * @since 1.1
997    */
998   public void checkMemberAccess(Class<?> c, int memberType)
999   {
1000     if (c == null)
1001       throw new NullPointerException();
1002     if (memberType == Member.PUBLIC)
1003       return;
1004     // XXX Allow access to classes created by same classloader before next
1005     // check.
1006     checkPermission(new RuntimePermission("accessDeclaredMembers"));
1007   }
1008
1009   /**
1010    * Test whether a particular security action may be taken. The default
1011    * implementation checks <code>SecurityPermission(action)</code>. If you
1012    * override this, call <code>super.checkSecurityAccess</code> rather than
1013    * throwing an exception.
1014    *
1015    * @param action the desired action to take
1016    * @throws SecurityException if permission is denied
1017    * @throws NullPointerException if action is null
1018    * @throws IllegalArgumentException if action is ""
1019    * @since 1.1
1020    */
1021   public void checkSecurityAccess(String action)
1022   {
1023     checkPermission(new SecurityPermission(action));
1024   }
1025
1026   /**
1027    * Get the ThreadGroup that a new Thread should belong to by default. Called
1028    * by Thread.Thread(). The default implementation returns the current
1029    * ThreadGroup of the current Thread. <STRONG>Spec Note:</STRONG> it is not
1030    * clear whether the new Thread is guaranteed to pass the
1031    * checkAccessThreadGroup() test when using this ThreadGroup, but I presume
1032    * so.
1033    *
1034    * @return the ThreadGroup to put the new Thread into
1035    * @since 1.1
1036    */
1037   public ThreadGroup getThreadGroup()
1038   {
1039     return Thread.currentThread().getThreadGroup();
1040   }
1041
1042   /**
1043    * Helper that checks a comma-separated list of restricted packages, from
1044    * <code>Security.getProperty("package.definition")</code>, for the given
1045    * package access permission. If packageName starts with or equals any
1046    * restricted package, it checks
1047    * <code>RuntimePermission(permission + packageName)</code>.
1048    *
1049    * @param packageName the package name to check access to
1050    * @param restriction "package.access" or "package.definition"
1051    * @param permission the base permission, including the '.'
1052    * @throws SecurityException if permission is denied
1053    * @throws NullPointerException if packageName is null
1054    * @see #checkPackageAccess(String)
1055    * @see #checkPackageDefinition(String)
1056    */
1057   void checkPackageList(String packageName, final String restriction,
1058                         String permission)
1059   {
1060     if (packageName == null)
1061       throw new NullPointerException();
1062
1063     String list = (String)AccessController.doPrivileged(new PrivilegedAction()
1064       {
1065         public Object run()
1066         {
1067           return Security.getProperty(restriction);
1068         }
1069       });
1070
1071     if (list == null || list.equals(""))
1072       return;
1073
1074     String packageNamePlusDot = packageName + ".";
1075
1076     StringTokenizer st = new StringTokenizer(list, ",");
1077     while (st.hasMoreTokens())
1078       {
1079         if (packageNamePlusDot.startsWith(st.nextToken()))
1080           {
1081             Permission p = new RuntimePermission(permission + packageName);
1082             checkPermission(p);
1083             return;
1084           }
1085       }
1086   }
1087 }