OSDN Git Service

2003-04-29 Michael Koch <konqueror@gmx.de>
[pf3gnuchains/gcc-fork.git] / libjava / java / util / PropertyPermission.java
1 /* PropertyPermission.java -- permission to get and set System properties
2    Copyright (C) 1999, 2000, 2002 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., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 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.util;
40
41 import java.security.Permission;
42 import java.security.BasicPermission;
43 import java.security.PermissionCollection;
44 import java.io.ObjectStreamField;
45 import java.io.ObjectInputStream;
46 import java.io.ObjectOutputStream;
47 import java.io.IOException;
48
49 /**
50  * This class represents the permission to access and modify a property.<br>
51  *
52  * The name is the name of the property, e.g. xxx.  You can also
53  * use an asterisk "*" as described in BasicPermission.<br>
54  *
55  * The action string is a comma-separated list of keywords.  There are
56  * two possible actions:
57  * <dl>
58  * <dt>read</dt>
59  * <dd>Allows to read the property via <code>System.getProperty</code>.</dd>
60  * <dt>write</dt>
61  * <dd>Allows to write the property via <code>System.setProperty</code>.</dd>
62  * </dl>
63  *
64  * The action string is case insensitive (it is converted to lower case).
65  *
66  * @see Permission
67  * @see BasicPermission
68  * @see SecurityManager
69  * @author Jochen Hoenicke
70  * @since 1.2
71  * @status updated to 1.4
72  */
73 public final class PropertyPermission extends BasicPermission
74 {
75   /**
76    * PropertyPermission uses a more efficient representation than the
77    * serialized form; this documents the difference.
78    *
79    * @serialField action String the action string
80    */
81   private static final ObjectStreamField[] serialPersistentFields =
82   {
83     new ObjectStreamField("action", String.class)
84   };
85
86   /**
87    * Compatible with JDK 1.2+.
88    */
89   private static final long serialVersionUID = 885438825399942851L;
90
91   /** Permission to read. */
92   private static final int READ = 1;
93   /** Permission to write. */
94   private static final int WRITE = 2;
95
96   /** The set of actions permitted. */
97   // Package visible for use by PropertyPermissionCollection.
98   transient int actions;
99
100   /**
101    * The String forms of the actions permitted.
102    */
103   private static final String actionStrings[] =
104   {
105     "", "read", "write", "read,write"
106   };
107
108   /**
109    * Constructs a PropertyPermission with the specified property.  Possible
110    * actions are read and write, comma-separated and case-insensitive.
111    *
112    * @param name the name of the property
113    * @param actions the action string
114    * @throws NullPointerException if name is null
115    * @throws IllegalArgumentException if name string contains an
116    *         illegal wildcard or actions string contains an illegal action
117    *         (this includes a null actions string)
118    */
119   public PropertyPermission(String name, String actions)
120   {
121     super(name);
122     if (actions == null)
123       throw new IllegalArgumentException();
124     setActions(actions.toLowerCase());
125   }
126
127   /**
128    * Parse the action string and convert actions from external to internal
129    * form.  This will set the internal actions field.
130    *
131    * @param str the action string
132    * @throws IllegalArgumentException if actions string contains an
133    *         illegal action
134    */
135   private void setActions(String str)
136   {
137     if ("read".equals(str))
138       actions = READ;
139     else if ("write".equals(str))
140       actions = WRITE;
141     else if ("read,write".equals(str) || "write,read".equals(str))
142       actions = READ | WRITE;
143     else
144       throw new IllegalArgumentException("illegal action " + str);
145   }
146
147   /**
148    * Reads an object from the stream. This converts the external to the
149    * internal representation.
150    *
151    * @param s the stream to read from
152    * @throws IOException if the stream fails
153    * @throws ClassNotFoundException if reserialization fails
154    */
155   private void readObject(ObjectInputStream s)
156     throws IOException, ClassNotFoundException
157   {
158     ObjectInputStream.GetField fields = s.readFields();
159     setActions((String) fields.get("actions", null));
160   }
161
162   /**
163    * Writes an object to the stream. This converts the internal to the
164    * external representation.
165    *
166    * @param s the stram to write to
167    * @throws IOException if the stream fails
168    */
169   private void writeObject(ObjectOutputStream s) throws IOException
170   {
171     ObjectOutputStream.PutField fields = s.putFields();
172     fields.put("actions", getActions());
173     s.writeFields();
174   }
175
176   /**
177    * Check if this permission implies p.  This returns true iff all of
178    * the following conditions are true:
179    * <ul>
180    * <li> p is a PropertyPermission </li>
181    * <li> this.getName() implies p.getName(),
182    *  e.g. <code>java.*</code> implies <code>java.home</code> </li>
183    * <li> this.getActions is a subset of p.getActions </li>
184    * </ul>
185    *
186    * @param p the permission to check
187    * @return true if this permission implies p
188    */
189   public boolean implies(Permission p)
190   {
191     // BasicPermission checks for name and type.
192     if (super.implies(p))
193       {
194         // We have to check the actions.
195         PropertyPermission pp = (PropertyPermission) p;
196         return (pp.actions & ~actions) == 0;
197       }
198     return false;
199   }
200
201   /**
202    * Check to see whether this object is the same as another
203    * PropertyPermission object; this is true if it has the same name and
204    * actions.
205    *
206    * @param obj the other object
207    * @return true if the two are equivalent
208    */
209   public boolean equals(Object obj)
210   {
211     return super.equals(obj) && actions == ((PropertyPermission) obj).actions;
212   }
213
214   /**
215    * Returns the hash code for this permission.  It is equivalent to
216    * <code>getName().hashCode()</code>.
217    *
218    * @return the hash code
219    */
220   public int hashCode()
221   {
222     return super.hashCode();
223   }
224
225   /**
226    * Returns the action string.  Note that this may differ from the string
227    * given at the constructor:  The actions are converted to lowercase and
228    * may be reordered.
229    *
230    * @return one of "read", "write", or "read,write"
231    */
232   public String getActions()
233   {
234     return actionStrings[actions];
235   }
236
237   /**
238    * Returns a permission collection suitable to take
239    * PropertyPermission objects.
240    *
241    * @return a new empty PermissionCollection
242    */
243   public PermissionCollection newPermissionCollection()
244   {
245     return new PropertyPermissionCollection();
246   }
247 }