jdk-sandbox: comparison jdk/src/java.base/share/classes/java/io/FilePermission.java

equal deleted inserted replaced

-:a6b5f444cb68
+:00a25f4c4d44
 /*
-* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 package java.io;
 import java.security.*;
 import java.util.Enumeration;
-import java.util.List;
+import java.util.StringJoiner;
-import java.util.ArrayList;
 import java.util.Vector;
-import java.util.Collections;
+import java.util.concurrent.ConcurrentHashMap;
-import java.util.StringJoiner;
 import sun.security.util.SecurityConstants;
 /**
 * This class represents access to a file or directory.  A FilePermission consists
 * of a pathname and a set of actions valid for that pathname.
 * <code>implies</code> method.
 *
 * @param path the pathname of the file/directory.
 * @param mask the action mask to use.
 */
 // package private for use by the FilePermissionCollection add method
 FilePermission(String path, int mask) {
 super(path);
 init(mask);
 }
 *
 * @return <code>true</code> if the specified permission is not
 *                  <code>null</code> and is implied by this object,
 *                  <code>false</code> otherwise.
 */
+@Override
 public boolean implies(Permission p) {
 if (!(p instanceof FilePermission))
 return false;
 FilePermission that = (FilePermission) p;
 * @param obj the object we are testing for equality with this object.
 * @return <code>true</code> if obj is a FilePermission, and has the same
 *          pathname and actions as this FilePermission object,
 *          <code>false</code> otherwise.
 */
+@Override
 public boolean equals(Object obj) {
 if (obj == this)
 return true;
 if (! (obj instanceof FilePermission))
 /**
 * Returns the hash code value for this object.
 *
 * @return a hash code value for this object.
 */
+@Override
 public int hashCode() {
 return 0;
 }
 /**
 * object allows both write and read actions, a call to <code>getActions</code>
 * will return the string "read,write".
 *
 * @return the canonical string representation of the actions.
 */
+@Override
 public String getActions() {
 if (actions == null)
 actions = getActions(this.mask);
 return actions;
 * returned by this <code>newPermissionCollection</code> method.
 *
 * @return a new PermissionCollection object suitable for storing
 * FilePermissions.
 */
+@Override
 public PermissionCollection newPermissionCollection() {
 return new FilePermissionCollection();
 }
 /**
 final class FilePermissionCollection extends PermissionCollection
 implements Serializable
 {
 // Not serialized; see serialization section at end of class
-private transient List<Permission> perms;
+private transient ConcurrentHashMap<String, Permission> perms;
 /**
 * Create an empty FilePermissionCollection object.
 */
 public FilePermissionCollection() {
-perms = new ArrayList<>();
+perms = new ConcurrentHashMap<>();
 }
 /**
 * Adds a permission to the FilePermissionCollection. The key for the hash is
 * permission.path.
 *                                       FilePermission
 *
 * @exception SecurityException - if this FilePermissionCollection object
 *                                has been marked readonly
 */
+@Override
 public void add(Permission permission) {
 if (! (permission instanceof FilePermission))
 throw new IllegalArgumentException("invalid permission: "+
 permission);
 if (isReadOnly())
 throw new SecurityException(
 "attempt to add a Permission to a readonly PermissionCollection");
-synchronized (this) {
+FilePermission fp = (FilePermission)permission;
-perms.add(permission);
-}
+// Add permission to map if it is absent, or replace with new
+// permission if applicable. NOTE: cannot use lambda for
+// remappingFunction parameter until JDK-8076596 is fixed.
+perms.merge(fp.getName(), fp,
+new java.util.function.BiFunction<>() {
+@Override
+public Permission apply(Permission existingVal,
+Permission newVal) {
+int oldMask = ((FilePermission)existingVal).getMask();
+int newMask = ((FilePermission)newVal).getMask();
+if (oldMask != newMask) {
+int effective = oldMask | newMask;
+if (effective == newMask) {
+return newVal;
+}
+if (effective != oldMask) {
+return new FilePermission(fp.getName(), effective);
+}
+}
+return existingVal;
+}
+}
+);
 }
 /**
 * Check and see if this set of permissions implies the permissions
 * expressed in "permission".
 * @param permission the Permission object to compare
 *
 * @return true if "permission" is a proper subset of a permission in
 * the set, false if not.
 */
+@Override
 public boolean implies(Permission permission) {
 if (! (permission instanceof FilePermission))
 return false;
-FilePermission fp = (FilePermission) permission;
+FilePermission fperm = (FilePermission) permission;
-int desired = fp.getMask();
+int desired = fperm.getMask();
 int effective = 0;
 int needed = desired;
-synchronized (this) {
+for (Permission perm : perms.values()) {
-int len = perms.size();
+FilePermission fp = (FilePermission)perm;
-for (int i = 0; i < len; i++) {
+if (((needed & fp.getMask()) != 0) && fp.impliesIgnoreMask(fperm)) {
-FilePermission x = (FilePermission) perms.get(i);
+effective |= fp.getMask();
-if (((needed & x.getMask()) != 0) && x.impliesIgnoreMask(fp)) {
+if ((effective & desired) == desired) {
-effective |=  x.getMask();
+return true;
-if ((effective & desired) == desired)
-return true;
-needed = (desired ^ effective);
 }
+needed = (desired ^ effective);
 }
 }
 return false;
 }
 * Returns an enumeration of all the FilePermission objects in the
 * container.
 *
 * @return an enumeration of all the FilePermission objects.
 */
+@Override
 public Enumeration<Permission> elements() {
-// Convert Iterator into Enumeration
+return perms.elements();
-synchronized (this) {
-return Collections.enumeration(perms);
-}
 }
 private static final long serialVersionUID = 2202956749081564585L;
 // Need to maintain serialization interoperability with earlier releases,
 */
 private void writeObject(ObjectOutputStream out) throws IOException {
 // Don't call out.defaultWriteObject()
 // Write out Vector
-Vector<Permission> permissions = new Vector<>(perms.size());
+Vector<Permission> permissions = new Vector<>(perms.values());
-synchronized (this) {
-permissions.addAll(perms);
-}
 ObjectOutputStream.PutField pfields = out.putFields();
 pfields.put("permissions", permissions);
 out.writeFields();
 }
 ObjectInputStream.GetField gfields = in.readFields();
 // Get the one we want
 @SuppressWarnings("unchecked")
 Vector<Permission> permissions = (Vector<Permission>)gfields.get("permissions", null);
-perms = new ArrayList<>(permissions.size());
+perms = new ConcurrentHashMap<>(permissions.size());
-perms.addAll(permissions);
+for (Permission perm : permissions) {
+perms.put(perm.getName(), perm);
+}
 }
 }

changeset 31080	00a25f4c4d44
parent 29986	97167d851fc4
child 32649	2ee9017c7597