001 /*
002 * Copyright 1997-2005 Sun Microsystems, Inc. All Rights Reserved.
003 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004 *
005 * This code is free software; you can redistribute it and/or modify it
006 * under the terms of the GNU General Public License version 2 only, as
007 * published by the Free Software Foundation. Sun designates this
008 * particular file as subject to the "Classpath" exception as provided
009 * by Sun in the LICENSE file that accompanied this code.
010 *
011 * This code is distributed in the hope that it will be useful, but WITHOUT
012 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014 * version 2 for more details (a copy is included in the LICENSE file that
015 * accompanied this code).
016 *
017 * You should have received a copy of the GNU General Public License version
018 * 2 along with this work; if not, write to the Free Software Foundation,
019 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020 *
021 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022 * CA 95054 USA or visit www.sun.com if you need additional information or
023 * have any questions.
024 */
025
026 package java.io;
027
028 import java.security.*;
029 import java.util.Enumeration;
030 import java.util.List;
031 import java.util.ArrayList;
032 import java.util.StringTokenizer;
033 import java.util.Vector;
034 import java.util.Collections;
035 import java.io.ObjectStreamField;
036 import java.io.ObjectOutputStream;
037 import java.io.ObjectInputStream;
038 import java.io.IOException;
039 import sun.security.util.SecurityConstants;
040
041 /**
042 * This class represents access to a file or directory. A FilePermission consists
043 * of a pathname and a set of actions valid for that pathname.
044 * <P>
045 * Pathname is the pathname of the file or directory granted the specified
046 * actions. A pathname that ends in "/*" (where "/" is
047 * the file separator character, <code>File.separatorChar</code>) indicates
048 * all the files and directories contained in that directory. A pathname
049 * that ends with "/-" indicates (recursively) all files
050 * and subdirectories contained in that directory. A pathname consisting of
051 * the special token "<<ALL FILES>>" matches <b>any</b> file.
052 * <P>
053 * Note: A pathname consisting of a single "*" indicates all the files
054 * in the current directory, while a pathname consisting of a single "-"
055 * indicates all the files in the current directory and
056 * (recursively) all files and subdirectories contained in the current
057 * directory.
058 * <P>
059 * The actions to be granted are passed to the constructor in a string containing
060 * a list of one or more comma-separated keywords. The possible keywords are
061 * "read", "write", "execute", and "delete". Their meaning is defined as follows:
062 * <P>
063 * <DL>
064 * <DT> read <DD> read permission
065 * <DT> write <DD> write permission
066 * <DT> execute
067 * <DD> execute permission. Allows <code>Runtime.exec</code> to
068 * be called. Corresponds to <code>SecurityManager.checkExec</code>.
069 * <DT> delete
070 * <DD> delete permission. Allows <code>File.delete</code> to
071 * be called. Corresponds to <code>SecurityManager.checkDelete</code>.
072 * </DL>
073 * <P>
074 * The actions string is converted to lowercase before processing.
075 * <P>
076 * Be careful when granting FilePermissions. Think about the implications
077 * of granting read and especially write access to various files and
078 * directories. The "<<ALL FILES>>" permission with write action is
079 * especially dangerous. This grants permission to write to the entire
080 * file system. One thing this effectively allows is replacement of the
081 * system binary, including the JVM runtime environment.
082 *
083 * <p>Please note: Code can always read a file from the same
084 * directory it's in (or a subdirectory of that directory); it does not
085 * need explicit permission to do so.
086 *
087 * @see java.security.Permission
088 * @see java.security.Permissions
089 * @see java.security.PermissionCollection
090 *
091 * @version 1.86 07/05/05
092 *
093 * @author Marianne Mueller
094 * @author Roland Schemers
095 * @since 1.2
096 *
097 * @serial exclude
098 */
099
100 public final class FilePermission extends Permission implements
101 Serializable {
102
103 /**
104 * Execute action.
105 */
106 private final static int EXECUTE = 0x1;
107 /**
108 * Write action.
109 */
110 private final static int WRITE = 0x2;
111 /**
112 * Read action.
113 */
114 private final static int READ = 0x4;
115 /**
116 * Delete action.
117 */
118 private final static int DELETE = 0x8;
119
120 /**
121 * All actions (read,write,execute,delete)
122 */
123 private final static int ALL = READ | WRITE | EXECUTE | DELETE;
124 /**
125 * No actions.
126 */
127 private final static int NONE = 0x0;
128
129 // the actions mask
130 private transient int mask;
131
132 // does path indicate a directory? (wildcard or recursive)
133 private transient boolean directory;
134
135 // is it a recursive directory specification?
136 private transient boolean recursive;
137
138 /**
139 * the actions string.
140 *
141 * @serial
142 */
143 private String actions; // Left null as long as possible, then
144 // created and re-used in the getAction function.
145
146 // canonicalized dir path. In the case of
147 // directories, it is the name "/blah/*" or "/blah/-" without
148 // the last character (the "*" or "-").
149
150 private transient String cpath;
151
152 // static Strings used by init(int mask)
153 private static final char RECURSIVE_CHAR = '-';
154 private static final char WILD_CHAR = '*';
155
156 /*
157 public String toString()
158 {
159 StringBuffer sb = new StringBuffer();
160 sb.append("***\n");
161 sb.append("cpath = "+cpath+"\n");
162 sb.append("mask = "+mask+"\n");
163 sb.append("actions = "+getActions()+"\n");
164 sb.append("directory = "+directory+"\n");
165 sb.append("recursive = "+recursive+"\n");
166 sb.append("***\n");
167 return sb.toString();
168 }
169 */
170
171 private static final long serialVersionUID = 7930732926638008763L;
172
173 /**
174 * initialize a FilePermission object. Common to all constructors.
175 * Also called during de-serialization.
176 *
177 * @param mask the actions mask to use.
178 *
179 */
180 private void init(int mask) {
181
182 if ((mask & ALL) != mask)
183 throw new IllegalArgumentException("invalid actions mask");
184
185 if (mask == NONE)
186 throw new IllegalArgumentException("invalid actions mask");
187
188 if ((cpath = getName()) == null)
189 throw new NullPointerException("name can't be null");
190
191 this .mask = mask;
192
193 if (cpath.equals("<<ALL FILES>>")) {
194 directory = true;
195 recursive = true;
196 cpath = "";
197 return;
198 }
199
200 // store only the canonical cpath if possible
201 cpath = AccessController
202 .doPrivileged(new PrivilegedAction<String>() {
203 public String run() {
204 try {
205 return sun.security.provider.PolicyFile
206 .canonPath(cpath);
207 } catch (IOException ioe) {
208 return cpath;
209 }
210 }
211 });
212
213 int len = cpath.length();
214 char last = ((len > 0) ? cpath.charAt(len - 1) : 0);
215
216 if (last == RECURSIVE_CHAR
217 && cpath.charAt(len - 2) == File.separatorChar) {
218 directory = true;
219 recursive = true;
220 cpath = cpath.substring(0, --len);
221 } else if (last == WILD_CHAR
222 && cpath.charAt(len - 2) == File.separatorChar) {
223 directory = true;
224 //recursive = false;
225 cpath = cpath.substring(0, --len);
226 } else {
227 // overkill since they are initialized to false, but
228 // commented out here to remind us...
229 //directory = false;
230 //recursive = false;
231 }
232
233 // XXX: at this point the path should be absolute. die if it isn't?
234 }
235
236 /**
237 * Creates a new FilePermission object with the specified actions.
238 * <i>path</i> is the pathname of a file or directory, and <i>actions</i>
239 * contains a comma-separated list of the desired actions granted on the
240 * file or directory. Possible actions are
241 * "read", "write", "execute", and "delete".
242 *
243 * <p>A pathname that ends in "/*" (where "/" is
244 * the file separator character, <code>File.separatorChar</code>)
245 * indicates all the files and directories contained in that directory.
246 * A pathname that ends with "/-" indicates (recursively) all files and
247 * subdirectories contained in that directory. The special pathname
248 * "<<ALL FILES>>" matches any file.
249 *
250 * <p>A pathname consisting of a single "*" indicates all the files
251 * in the current directory, while a pathname consisting of a single "-"
252 * indicates all the files in the current directory and
253 * (recursively) all files and subdirectories contained in the current
254 * directory.
255 *
256 * <p>A pathname containing an empty string represents an empty path.
257 *
258 * @param path the pathname of the file/directory.
259 * @param actions the action string.
260 *
261 * @throws IllegalArgumentException
262 * If actions is <code>null</code>, empty or contains an action
263 * other than the specified possible actions.
264 */
265
266 public FilePermission(String path, String actions) {
267 super (path);
268 init(getMask(actions));
269 }
270
271 /**
272 * Creates a new FilePermission object using an action mask.
273 * More efficient than the FilePermission(String, String) constructor.
274 * Can be used from within
275 * code that needs to create a FilePermission object to pass into the
276 * <code>implies</code> method.
277 *
278 * @param path the pathname of the file/directory.
279 * @param mask the action mask to use.
280 */
281
282 // package private for use by the FilePermissionCollection add method
283 FilePermission(String path, int mask) {
284 super (path);
285 init(mask);
286 }
287
288 /**
289 * Checks if this FilePermission object "implies" the specified permission.
290 * <P>
291 * More specifically, this method returns true if:<p>
292 * <ul>
293 * <li> <i>p</i> is an instanceof FilePermission,<p>
294 * <li> <i>p</i>'s actions are a proper subset of this
295 * object's actions, and <p>
296 * <li> <i>p</i>'s pathname is implied by this object's
297 * pathname. For example, "/tmp/*" implies "/tmp/foo", since
298 * "/tmp/*" encompasses all files in the "/tmp" directory,
299 * including the one named "foo".
300 * </ul>
301 *
302 * @param p the permission to check against.
303 *
304 * @return <code>true</code> if the specified permission is not
305 * <code>null</code> and is implied by this object,
306 * <code>false</code> otherwise.
307 */
308 public boolean implies(Permission p) {
309 if (!(p instanceof FilePermission))
310 return false;
311
312 FilePermission that = (FilePermission) p;
313
314 // we get the effective mask. i.e., the "and" of this and that.
315 // They must be equal to that.mask for implies to return true.
316
317 return ((this .mask & that.mask) == that.mask)
318 && impliesIgnoreMask(that);
319 }
320
321 /**
322 * Checks if the Permission's actions are a proper subset of the
323 * this object's actions. Returns the effective mask iff the
324 * this FilePermission's path also implies that FilePermission's path.
325 *
326 * @param that the FilePermission to check against.
327 * @param exact return immediately if the masks are not equal
328 * @return the effective mask
329 */
330 boolean impliesIgnoreMask(FilePermission that) {
331 if (this .directory) {
332 if (this .recursive) {
333 // make sure that.path is longer then path so
334 // something like /foo/- does not imply /foo
335 if (that.directory) {
336 return (that.cpath.length() >= this .cpath.length())
337 && that.cpath.startsWith(this .cpath);
338 } else {
339 return ((that.cpath.length() > this .cpath.length()) && that.cpath
340 .startsWith(this .cpath));
341 }
342 } else {
343 if (that.directory) {
344 // if the permission passed in is a directory
345 // specification, make sure that a non-recursive
346 // permission (i.e., this object) can't imply a recursive
347 // permission.
348 if (that.recursive)
349 return false;
350 else
351 return (this .cpath.equals(that.cpath));
352 } else {
353 int last = that.cpath
354 .lastIndexOf(File.separatorChar);
355 if (last == -1)
356 return false;
357 else {
358 // this.cpath.equals(that.cpath.substring(0, last+1));
359 // Use regionMatches to avoid creating new string
360 return (this .cpath.length() == (last + 1))
361 && this .cpath.regionMatches(0,
362 that.cpath, 0, last + 1);
363 }
364 }
365 }
366 } else if (that.directory) {
367 // if this is NOT recursive/wildcarded,
368 // do not let it imply a recursive/wildcarded permission
369 return false;
370 } else {
371 return (this .cpath.equals(that.cpath));
372 }
373 }
374
375 /**
376 * Checks two FilePermission objects for equality. Checks that <i>obj</i> is
377 * a FilePermission, and has the same pathname and actions as this object.
378 * <P>
379 * @param obj the object we are testing for equality with this object.
380 * @return <code>true</code> if obj is a FilePermission, and has the same
381 * pathname and actions as this FilePermission object,
382 * <code>false</code> otherwise.
383 */
384 public boolean equals(Object obj) {
385 if (obj == this )
386 return true;
387
388 if (!(obj instanceof FilePermission))
389 return false;
390
391 FilePermission that = (FilePermission) obj;
392
393 return (this .mask == that.mask)
394 && this .cpath.equals(that.cpath)
395 && (this .directory == that.directory)
396 && (this .recursive == that.recursive);
397 }
398
399 /**
400 * Returns the hash code value for this object.
401 *
402 * @return a hash code value for this object.
403 */
404
405 public int hashCode() {
406 return this .cpath.hashCode();
407 }
408
409 /**
410 * Converts an actions String to an actions mask.
411 *
412 * @param action the action string.
413 * @return the actions mask.
414 */
415 private static int getMask(String actions) {
416
417 int mask = NONE;
418
419 // Null action valid?
420 if (actions == null) {
421 return mask;
422 }
423 // Check against use of constants (used heavily within the JDK)
424 if (actions == SecurityConstants.FILE_READ_ACTION) {
425 return READ;
426 } else if (actions == SecurityConstants.FILE_WRITE_ACTION) {
427 return WRITE;
428 } else if (actions == SecurityConstants.FILE_EXECUTE_ACTION) {
429 return EXECUTE;
430 } else if (actions == SecurityConstants.FILE_DELETE_ACTION) {
431 return DELETE;
432 }
433
434 char[] a = actions.toCharArray();
435
436 int i = a.length - 1;
437 if (i < 0)
438 return mask;
439
440 while (i != -1) {
441 char c;
442
443 // skip whitespace
444 while ((i != -1)
445 && ((c = a[i]) == ' ' || c == '\r' || c == '\n'
446 || c == '\f' || c == '\t'))
447 i--;
448
449 // check for the known strings
450 int matchlen;
451
452 if (i >= 3 && (a[i - 3] == 'r' || a[i - 3] == 'R')
453 && (a[i - 2] == 'e' || a[i - 2] == 'E')
454 && (a[i - 1] == 'a' || a[i - 1] == 'A')
455 && (a[i] == 'd' || a[i] == 'D')) {
456 matchlen = 4;
457 mask |= READ;
458
459 } else if (i >= 4 && (a[i - 4] == 'w' || a[i - 4] == 'W')
460 && (a[i - 3] == 'r' || a[i - 3] == 'R')
461 && (a[i - 2] == 'i' || a[i - 2] == 'I')
462 && (a[i - 1] == 't' || a[i - 1] == 'T')
463 && (a[i] == 'e' || a[i] == 'E')) {
464 matchlen = 5;
465 mask |= WRITE;
466
467 } else if (i >= 6 && (a[i - 6] == 'e' || a[i - 6] == 'E')
468 && (a[i - 5] == 'x' || a[i - 5] == 'X')
469 && (a[i - 4] == 'e' || a[i - 4] == 'E')
470 && (a[i - 3] == 'c' || a[i - 3] == 'C')
471 && (a[i - 2] == 'u' || a[i - 2] == 'U')
472 && (a[i - 1] == 't' || a[i - 1] == 'T')
473 && (a[i] == 'e' || a[i] == 'E')) {
474 matchlen = 7;
475 mask |= EXECUTE;
476
477 } else if (i >= 5 && (a[i - 5] == 'd' || a[i - 5] == 'D')
478 && (a[i - 4] == 'e' || a[i - 4] == 'E')
479 && (a[i - 3] == 'l' || a[i - 3] == 'L')
480 && (a[i - 2] == 'e' || a[i - 2] == 'E')
481 && (a[i - 1] == 't' || a[i - 1] == 'T')
482 && (a[i] == 'e' || a[i] == 'E')) {
483 matchlen = 6;
484 mask |= DELETE;
485
486 } else {
487 // parse error
488 throw new IllegalArgumentException(
489 "invalid permission: " + actions);
490 }
491
492 // make sure we didn't just match the tail of a word
493 // like "ackbarfaccept". Also, skip to the comma.
494 boolean seencomma = false;
495 while (i >= matchlen && !seencomma) {
496 switch (a[i - matchlen]) {
497 case ',':
498 seencomma = true;
499 /*FALLTHROUGH*/
500 case ' ':
501 case '\r':
502 case '\n':
503 case '\f':
504 case '\t':
505 break;
506 default:
507 throw new IllegalArgumentException(
508 "invalid permission: " + actions);
509 }
510 i--;
511 }
512
513 // point i at the location of the comma minus one (or -1).
514 i -= matchlen;
515 }
516
517 return mask;
518 }
519
520 /**
521 * Return the current action mask. Used by the FilePermissionCollection.
522 *
523 * @return the actions mask.
524 */
525
526 int getMask() {
527 return mask;
528 }
529
530 /**
531 * Return the canonical string representation of the actions.
532 * Always returns present actions in the following order:
533 * read, write, execute, delete.
534 *
535 * @return the canonical string representation of the actions.
536 */
537 private static String getActions(int mask) {
538 StringBuilder sb = new StringBuilder();
539 boolean comma = false;
540
541 if ((mask & READ) == READ) {
542 comma = true;
543 sb.append("read");
544 }
545
546 if ((mask & WRITE) == WRITE) {
547 if (comma)
548 sb.append(',');
549 else
550 comma = true;
551 sb.append("write");
552 }
553
554 if ((mask & EXECUTE) == EXECUTE) {
555 if (comma)
556 sb.append(',');
557 else
558 comma = true;
559 sb.append("execute");
560 }
561
562 if ((mask & DELETE) == DELETE) {
563 if (comma)
564 sb.append(',');
565 else
566 comma = true;
567 sb.append("delete");
568 }
569
570 return sb.toString();
571 }
572
573 /**
574 * Returns the "canonical string representation" of the actions.
575 * That is, this method always returns present actions in the following order:
576 * read, write, execute, delete. For example, if this FilePermission object
577 * allows both write and read actions, a call to <code>getActions</code>
578 * will return the string "read,write".
579 *
580 * @return the canonical string representation of the actions.
581 */
582 public String getActions() {
583 if (actions == null)
584 actions = getActions(this .mask);
585
586 return actions;
587 }
588
589 /**
590 * Returns a new PermissionCollection object for storing FilePermission
591 * objects.
592 * <p>
593 * FilePermission objects must be stored in a manner that allows them
594 * to be inserted into the collection in any order, but that also enables the
595 * PermissionCollection <code>implies</code>
596 * method to be implemented in an efficient (and consistent) manner.
597 *
598 * <p>For example, if you have two FilePermissions:
599 * <OL>
600 * <LI> <code>"/tmp/-", "read"</code>
601 * <LI> <code>"/tmp/scratch/foo", "write"</code>
602 * </OL>
603 *
604 * <p>and you are calling the <code>implies</code> method with the FilePermission:
605 *
606 * <pre>
607 * "/tmp/scratch/foo", "read,write",
608 * </pre>
609 *
610 * then the <code>implies</code> function must
611 * take into account both the "/tmp/-" and "/tmp/scratch/foo"
612 * permissions, so the effective permission is "read,write",
613 * and <code>implies</code> returns true. The "implies" semantics for
614 * FilePermissions are handled properly by the PermissionCollection object
615 * returned by this <code>newPermissionCollection</code> method.
616 *
617 * @return a new PermissionCollection object suitable for storing
618 * FilePermissions.
619 */
620
621 public PermissionCollection newPermissionCollection() {
622 return new FilePermissionCollection();
623 }
624
625 /**
626 * WriteObject is called to save the state of the FilePermission
627 * to a stream. The actions are serialized, and the superclass
628 * takes care of the name.
629 */
630 private void writeObject(ObjectOutputStream s) throws IOException {
631 // Write out the actions. The superclass takes care of the name
632 // call getActions to make sure actions field is initialized
633 if (actions == null)
634 getActions();
635 s.defaultWriteObject();
636 }
637
638 /**
639 * readObject is called to restore the state of the FilePermission from
640 * a stream.
641 */
642 private void readObject(ObjectInputStream s) throws IOException,
643 ClassNotFoundException {
644 // Read in the actions, then restore everything else by calling init.
645 s.defaultReadObject();
646 init(getMask(actions));
647 }
648 }
649
650 /**
651 * A FilePermissionCollection stores a set of FilePermission permissions.
652 * FilePermission objects
653 * must be stored in a manner that allows them to be inserted in any
654 * order, but enable the implies function to evaluate the implies
655 * method.
656 * For example, if you have two FilePermissions:
657 * <OL>
658 * <LI> "/tmp/-", "read"
659 * <LI> "/tmp/scratch/foo", "write"
660 * </OL>
661 * And you are calling the implies function with the FilePermission:
662 * "/tmp/scratch/foo", "read,write", then the implies function must
663 * take into account both the /tmp/- and /tmp/scratch/foo
664 * permissions, so the effective permission is "read,write".
665 *
666 * @see java.security.Permission
667 * @see java.security.Permissions
668 * @see java.security.PermissionCollection
669 *
670 * @version 1.86 05/05/07
671 *
672 * @author Marianne Mueller
673 * @author Roland Schemers
674 *
675 * @serial include
676 *
677 */
678
679 final class FilePermissionCollection extends PermissionCollection
680 implements Serializable {
681
682 // Not serialized; see serialization section at end of class
683 private transient List perms;
684
685 /**
686 * Create an empty FilePermissions object.
687 *
688 */
689
690 public FilePermissionCollection() {
691 perms = new ArrayList();
692 }
693
694 /**
695 * Adds a permission to the FilePermissions. The key for the hash is
696 * permission.path.
697 *
698 * @param permission the Permission object to add.
699 *
700 * @exception IllegalArgumentException - if the permission is not a
701 * FilePermission
702 *
703 * @exception SecurityException - if this FilePermissionCollection object
704 * has been marked readonly
705 */
706
707 public void add(Permission permission) {
708 if (!(permission instanceof FilePermission))
709 throw new IllegalArgumentException("invalid permission: "
710 + permission);
711 if (isReadOnly())
712 throw new SecurityException(
713 "attempt to add a Permission to a readonly PermissionCollection");
714
715 synchronized (this ) {
716 perms.add(permission);
717 }
718 }
719
720 /**
721 * Check and see if this set of permissions implies the permissions
722 * expressed in "permission".
723 *
724 * @param p the Permission object to compare
725 *
726 * @return true if "permission" is a proper subset of a permission in
727 * the set, false if not.
728 */
729
730 public boolean implies(Permission permission) {
731 if (!(permission instanceof FilePermission))
732 return false;
733
734 FilePermission fp = (FilePermission) permission;
735
736 int desired = fp.getMask();
737 int effective = 0;
738 int needed = desired;
739
740 synchronized (this ) {
741 int len = perms.size();
742 for (int i = 0; i < len; i++) {
743 FilePermission x = (FilePermission) perms.get(i);
744 if (((needed & x.getMask()) != 0)
745 && x.impliesIgnoreMask(fp)) {
746 effective |= x.getMask();
747 if ((effective & desired) == desired)
748 return true;
749 needed = (desired ^ effective);
750 }
751 }
752 }
753 return false;
754 }
755
756 /**
757 * Returns an enumeration of all the FilePermission objects in the
758 * container.
759 *
760 * @return an enumeration of all the FilePermission objects.
761 */
762
763 public Enumeration elements() {
764 // Convert Iterator into Enumeration
765 synchronized (this ) {
766 return Collections.enumeration(perms);
767 }
768 }
769
770 private static final long serialVersionUID = 2202956749081564585L;
771
772 // Need to maintain serialization interoperability with earlier releases,
773 // which had the serializable field:
774 // private Vector permissions;
775
776 /**
777 * @serialField permissions java.util.Vector
778 * A list of FilePermission objects.
779 */
780 private static final ObjectStreamField[] serialPersistentFields = { new ObjectStreamField(
781 "permissions", Vector.class), };
782
783 /**
784 * @serialData "permissions" field (a Vector containing the FilePermissions).
785 */
786 /*
787 * Writes the contents of the perms field out as a Vector for
788 * serialization compatibility with earlier releases.
789 */
790 private void writeObject(ObjectOutputStream out) throws IOException {
791 // Don't call out.defaultWriteObject()
792
793 // Write out Vector
794 Vector permissions = new Vector(perms.size());
795 synchronized (this ) {
796 permissions.addAll(perms);
797 }
798
799 ObjectOutputStream.PutField pfields = out.putFields();
800 pfields.put("permissions", permissions);
801 out.writeFields();
802 }
803
804 /*
805 * Reads in a Vector of FilePermissions and saves them in the perms field.
806 */
807 private void readObject(ObjectInputStream in) throws IOException,
808 ClassNotFoundException {
809 // Don't call defaultReadObject()
810
811 // Read in serialized fields
812 ObjectInputStream.GetField gfields = in.readFields();
813
814 // Get the one we want
815 Vector permissions = (Vector) gfields.get("permissions", null);
816 perms = new ArrayList(permissions.size());
817 perms.addAll(permissions);
818 }
819 }
|