| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package java.security; |
| |
| /** |
| * The vm vendor may choose to implement this class. The reference |
| * implementation must be used if the reference implementation of |
| * AccessController is used. |
| * |
| * An AccessControlContext encapsulates the information which is needed by class |
| * AccessController to detect if a Permission would be granted at a particular |
| * point in a programs execution. |
| * |
| */ |
| |
| public final class AccessControlContext { |
| DomainCombiner domainCombiner; |
| |
| ProtectionDomain[] domainsArray; |
| |
| private static final SecurityPermission createAccessControlContext = new SecurityPermission( |
| "createAccessControlContext"); |
| |
| private static final SecurityPermission getDomainCombiner = new SecurityPermission( |
| "getDomainCombiner"); |
| |
| /** |
| * Constructs a new instance of this class given an array of protection |
| * domains. |
| * |
| */ |
| public AccessControlContext(ProtectionDomain[] context) { |
| int length = context.length; |
| int domainIndex = 0; |
| this.domainsArray = new ProtectionDomain[length]; |
| next: for (int i = 0; i < length; i++) { |
| ProtectionDomain current = context[i]; |
| for (int j = 0; j < i; j++) |
| if (current == this.domainsArray[j]) |
| continue next; |
| this.domainsArray[domainIndex++] = current; |
| } |
| if (domainIndex != length) { |
| ProtectionDomain[] copy = new ProtectionDomain[domainIndex]; |
| System.arraycopy(this.domainsArray, 0, copy, 0, domainIndex); |
| this.domainsArray = copy; |
| } |
| } |
| |
| AccessControlContext(ProtectionDomain[] context, boolean ignored) { |
| domainsArray = context; |
| } |
| |
| /** |
| * Constructs a new instance of this class given a context and a |
| * DomainCombiner |
| */ |
| public AccessControlContext(AccessControlContext acc, |
| DomainCombiner combiner) { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) |
| security.checkPermission(createAccessControlContext); |
| this.domainsArray = acc.domainsArray; |
| this.domainCombiner = combiner; |
| } |
| |
| /** |
| * Checks if the permission <code>perm</code> is allowed in this context. |
| * All ProtectionDomains must grant the permission for it to be granted. |
| * |
| * @param perm |
| * java.security.Permission the permission to check |
| * @exception java.security.AccessControlException |
| * thrown when perm is not granted. |
| */ |
| public void checkPermission(Permission perm) throws AccessControlException { |
| if (perm == null) |
| throw new NullPointerException(); |
| int i = domainsArray.length; |
| while (--i >= 0 && domainsArray[i].implies(perm)) |
| ; |
| if (i >= 0) { |
| throw new AccessControlException("Access Denied", perm); |
| } |
| } |
| |
| /** |
| * Compares the argument to the receiver, and answers true if they represent |
| * the <em>same</em> object using a class specific comparison. In this |
| * case, they must both be AccessControlContexts and contain the same |
| * protection domains. |
| * |
| * |
| * @param o |
| * the object to compare with this object |
| * @return <code>true</code> if the object is the same as this object |
| * <code>false</code> if it is different from this object |
| * @see #hashCode |
| */ |
| public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| if (o == null || this.getClass() != o.getClass()) |
| return false; |
| AccessControlContext otherContext = (AccessControlContext) o; |
| ProtectionDomain[] otherDomains = otherContext.domainsArray; |
| int length = domainsArray.length; |
| if (length != otherDomains.length) |
| return false; |
| |
| next: for (int i = 0; i < length; i++) { |
| ProtectionDomain current = domainsArray[i]; |
| for (int j = 0; j < length; j++) |
| if (current == otherDomains[j]) |
| continue next; |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Answers an integer hash code for the receiver. Any two objects which |
| * answer <code>true</code> when passed to <code>equals</code> must |
| * answer the same value for this method. |
| * |
| * |
| * @return the receiver's hash |
| * |
| * @see #equals |
| */ |
| public int hashCode() { |
| int result = 0; |
| int i = domainsArray.length; |
| while (--i >= 0) |
| result ^= domainsArray[i].hashCode(); |
| return result; |
| } |
| |
| /** |
| * Answers the DomainCombiner for the receiver. |
| * |
| */ |
| public DomainCombiner getDomainCombiner() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) |
| security.checkPermission(getDomainCombiner); |
| return domainCombiner; |
| } |
| |
| } |