/*
 * 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.
 */
/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed 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;

import java.util.ArrayList;
import org.apache.harmony.security.fortress.PolicyUtils;

/**
 * {@code AccessControlContext} encapsulates the {@code ProtectionDomain}s on
 * which access control decisions are based.
 */
public final class AccessControlContext {

    // List of ProtectionDomains wrapped by the AccessControlContext
    // It has the following characteristics:
    //     - 'context' can not be null
    //     - never contains null(s)
    //     - all elements are unique (no dups)
    ProtectionDomain[] context;

    DomainCombiner combiner;

    // An AccessControlContext inherited by the current thread from its parent
    private AccessControlContext inherited;

    /**
     * Constructs a new instance of {@code AccessControlContext} with the
     * specified {@code AccessControlContext} and {@code DomainCombiner}.
     * <p>
     * If a {@code SecurityManager} is installed, code calling this constructor
     * need the {@code SecurityPermission} {@code createAccessControlContext} to
     * be granted, otherwise a {@code SecurityException} will be thrown.
     *
     * @param acc
     *            the {@code AccessControlContext} related to the given {@code
     *            DomainCombiner}
     * @param combiner
     *            the {@code DomainCombiner} related to the given {@code
     *            AccessControlContext}
     * @throws SecurityException
     *             if a {@code SecurityManager} is installed and the caller does
     *             not have permission to invoke this constructor
     * @throws NullPointerException
     *             if {@code acc} is {@code null}
     */
    public AccessControlContext(AccessControlContext acc,
            DomainCombiner combiner) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new SecurityPermission(
                    "createAccessControlContext"));
        }
        // no need to clone() here as ACC is immutable
        this.context = acc.context;
        this.combiner = combiner;
    }

    /**
     * Constructs a new instance of {@code AccessControlContext} with the
     * specified array of {@code ProtectionDomain}s.
     *
     * @param context
     *            the {@code ProtectionDomain}s that are used to perform access
     *            checks in the context of this {@code AccessControlContext}
     * @throws NullPointerException
     *             if {@code context} is {@code null}
     */
    public AccessControlContext(ProtectionDomain[] context) {
        if (context == null) {
            throw new NullPointerException("context can not be null");
        }
        if (context.length != 0) {
            // remove dup entries
            ArrayList<ProtectionDomain> a = new ArrayList<ProtectionDomain>();
            for (int i = 0; i < context.length; i++) {
                if (context[i] != null && !a.contains(context[i])) {
                    a.add(context[i]);
                }
            }
            if (a.size() != 0) {
                this.context = new ProtectionDomain[a.size()];
                a.toArray(this.context);
            }
        }
        if (this.context == null) {
            // Prevent numerous checks for 'context==null'
            this.context = new ProtectionDomain[0];
        }
    }

    /**
     * Package-level ctor which is used in AccessController.<br>
     * ProtectionDomains passed as <code>stack</code> is then passed into
     * {@link #AccessControlContext(ProtectionDomain[])}, therefore:<br>
     * <il>
     * <li>it must not be null
     * <li>duplicates will be removed
     * <li>null-s will be removed
     * </li>
     *
     * @param stack - array of ProtectionDomains
     * @param inherited - inherited context, which may be null
     */
    AccessControlContext(ProtectionDomain[] stack,
            AccessControlContext inherited) {
        this(stack); // removes dups, removes nulls, checks for stack==null
        this.inherited = inherited;
    }

    /**
     * Package-level ctor which is used in AccessController.<br>
     * ProtectionDomains passed as <code>stack</code> is then passed into
     * {@link #AccessControlContext(ProtectionDomain[])}, therefore:<br>
     * <il>
     * <li>it must not be null
     * <li>duplicates will be removed
     * <li>null-s will be removed
     * </li>
     *
     * @param stack - array of ProtectionDomains
     * @param combiner - combiner
     */
    AccessControlContext(ProtectionDomain[] stack,
            DomainCombiner combiner) {
        this(stack); // removes dups, removes nulls, checks for stack==null
        this.combiner = combiner;
    }

    /**
     * Checks the specified permission against the vm's current security policy.
     * The check is based on this {@code AccessControlContext} as opposed to the
     * {@link AccessController#checkPermission(Permission)} method which
     * performs access checks based on the context of the current thread. This
     * method returns silently if the permission is granted, otherwise an
     * {@code AccessControlException} is thrown.
     * <p>
     * A permission is considered granted if every {@link ProtectionDomain} in
     * this context has been granted the specified permission.
     * <p>
     * If privileged operations are on the call stack, only the {@code
     * ProtectionDomain}s from the last privileged operation are taken into
     * account.
     * <p>
     * If inherited methods are on the call stack, the protection domains of the
     * declaring classes are checked, not the protection domains of the classes
     * on which the method is invoked.
     *
     * @param perm
     *            the permission to check against the policy
     * @throws AccessControlException
     *             if the specified permission is not granted
     * @throws NullPointerException
     *             if the specified permission is {@code null}
     * @see AccessController#checkPermission(Permission)
     */
    public void checkPermission(Permission perm) throws AccessControlException {
        if (perm == null) {
            throw new NullPointerException("Permission cannot be null");
        }
        for (int i = 0; i < context.length; i++) {
            if (!context[i].implies(perm)) {
                throw new AccessControlException("Permission check failed "
                        + perm, perm);
            }
        }
        if (inherited != null) {
            inherited.checkPermission(perm);
        }
    }


    /**
     * Compares the specified object with this {@code AccessControlContext} for
     * equality. Returns {@code true} if the specified object is also an
     * instance of {@code AccessControlContext}, and the two contexts
     * encapsulate the same {@code ProtectionDomain}s. The order of the {@code
     * ProtectionDomain}s is ignored by this method.
     *
     * @param obj
     *            object to be compared for equality with this {@code
     *            AccessControlContext}
     * @return {@code true} if the specified object is equal to this {@code
     *         AccessControlContext}, otherwise {@code false}
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof AccessControlContext) {
            AccessControlContext that = (AccessControlContext) obj;
            if (!(PolicyUtils.matchSubset(context, that.context) && PolicyUtils
                    .matchSubset(that.context, context))) {
                return false;
            }
            // BEGIN android-changed
            if (combiner != null) {
                return combiner.equals(that.combiner);
            }
            return that.combiner == null;
            // END android-changed
        }
        return false;
    }

    /**
     * Returns the {@code DomainCombiner} associated with this {@code
     * AccessControlContext}.
     * <p>
     * If a {@code SecurityManager} is installed, code calling this method needs
     * the {@code SecurityPermission} {@code getDomainCombiner} to be granted,
     * otherwise a {@code SecurityException} will be thrown.
     *
     * @return the {@code DomainCombiner} associated with this {@code
     *         AccessControlContext}
     * @throws SecurityException
     *             if a {@code SecurityManager} is installed and the caller does
     *             not have permission to invoke this method
     */
    public DomainCombiner getDomainCombiner() {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new SecurityPermission("getDomainCombiner"));
        }
        return combiner;
    }


    /**
     * Returns the hash code value for this {@code AccessControlContext}.
     * Returns the same hash code for {@code AccessControlContext}s that are
     * equal to each other as required by the general contract of
     * {@link Object#hashCode}.
     *
     * @return the hash code value for this {@code AccessControlContext}
     * @see Object#equals(Object)
     * @see AccessControlContext#equals(Object)
     */
    public int hashCode() {
        int hash = 0;
        for (int i = 0; i < context.length; i++) {
            hash ^= context[i].hashCode();
        }
        return hash;
    }

}
